OthmanAdi/planning-with-files
67.6
Adequate · 16 November 2026
17.7k
lines of production code
Python
primary language
5
measurements over time
What this system is
Features
Add 'Planning with Files' prompt for structured task management
A new 'Planning with Files' prompt has been added to the Continue integration, enabling a structured workflow that persists plans, findings, and progress into three specific Markdown files (task\_plan.md, findings.md, progress.md). This feature helps prevent context drift by guiding the AI to initialize these files via provided scripts, update task statuses, log errors, and record session actions, ensuring that key decisions and research conclusions are consistently tracked rather than relying solely on chat memory.
.continue/prompts · high confidence
Add Cursor integration hooks for planning context injection
Adds PowerShell and Bash hook scripts to .cursor/hooks (preToolUse, postToolUse, sessionStart, stop, and user-prompt-submit) that integrate the planning-with-files system with Cursor. These hooks inject plan context into the session on start and on every user message, provide a post-tool-use reminder to update progress, and check for incomplete phases to auto-continue the task. The implementation includes a shared plan resolver for PowerShell, handles UTF-8 encoding and Windows-specific path/link-type checks, respects the PLANNING\_DISABLED opt-out, and detects nested plan conflicts to prevent ambiguous context injection.
.cursor/hooks · high confidence
Add Gemini CLI hooks for file-based planning context
Added four executable shell scripts (before-agent, after-tool, session-start, session-end) to the .gemini/hooks directory to integrate Gemini CLI with the 'planning-with-files' skill. These hooks inject context from task\_plan.md into the agent's prompt, remind the agent to update progress after file writes, and restore project context at session start without relying on local session stores.
.gemini/hooks · high confidence
Add planning-with-files plugin entry point
A new plugin entry point at .opencode/plugins/planning-with-files.ts has been added to support dogfooding the repository by loading the plugin from source, while directing users to install the published package for production use.
.opencode/plugins · high confidence
Add planning-with-files skill assets and scripts
This change introduces the core assets for the 'planning-with-files' Kiro skill, including bootstrap scripts for Windows (PowerShell) and Unix (sh) that install planning templates into the workspace, and a Python 'session-catchup' script to help agents re-orient after context resets. It also adds the template files themselves (task\_plan.md, findings.md, progress.md, planning-context.md) which define the structure for multi-step task planning, phase tracking, and progress logging. Additionally, a 'check-complete' script is provided for both PowerShell and sh to report the completion status of phases defined in task\_plan.md, supporting an opt-out via the PLANNING\_DISABLED environment variable.
.kiro/skills/planning-with-files/assets · high confidence
Arabic localization of the planning-with-files skill
Added the Arabic variant of the planning-with-files skill under skills/i18n/planning-with-files-ar, including the SKILL.md definition, lifecycle hook dispatchers, and platform-specific scripts (PowerShell and shell) for session initialization, plan attestation, completion checking, and context injection. This provides the same file-based planning workflow and hook integration as the English skill, but with Arabic-language instructions, templates, and output messages.
skills/i18n · high confidence
Introduce Claude Code plugin lifecycle hooks and fix hook context encoding
This change adds the \hooks/claude-hook.sh\ dispatcher and \hooks/hooks.json\ configuration to integrate the Planning with Files plugin with Claude Code, enabling lifecycle events like session start, user prompt submission, and tool use. The shell script optimizes performance by using a Python fast-path to reduce process forking and ensures consistent JSON-string encoding of hook context across different \awk\ variants by enforcing \LC\_ALL=C\. Additionally, \hooks/codex-hooks.json\ is added to define the corresponding lifecycle hooks for the Codex integration. Also in this area: 1 commit (1 fix) fixing hooks; Fix hook execution isolation and add Qoder plugin support.
hooks · medium confidence · unverified
Introduce Codex hook adapter and cross-platform hook execution
Adds a new Python-based hook adapter and dispatcher to the .codex/hooks directory, enabling cross-platform execution of planning hooks on Windows (via pwf-hook.cmd and run\_sh.py) and POSIX systems. The adapter standardizes payload handling, session isolation, and plan resolution, while specific hooks (PreToolUse, PostToolUse, Stop, PermissionRequest, PreCompact) now provide context-aware nudges and decision logic to the Codex agent, including safeguards against ambiguous plans and reparse-point paths.
.codex/hooks · high confidence
Introduce plan attestation and completion gating for the planning-with-files skill
The planning-with-files skill now includes scripts to cryptographically attest plan files and enforce completion gates. The new \attest-plan\ scripts (PowerShell and shell) compute and store SHA-256 hashes of \task\_plan.md\ files, allowing the system to detect and warn about plan tampering. Additionally, the \check-complete\ and \gate-stop\ scripts implement a v3 completion gate that can block the Stop hook from terminating a session if specific conditions are met (e.g., phases are still in progress, gate mode is enabled via \.mode\, and block limits are not exceeded). These changes enhance security and workflow control by ensuring plan integrity and enforcing structured completion states.
.agents/skills/planning-with-files/scripts · high confidence
Introduce planning-with-files Pi extension with plan attestation and anchor resolution
The new planning-with-files extension provides lifecycle automation for the planning skill, mapping events like session start and tool calls to reminders and auto-continuation. It introduces plan attestation to detect tampered plan files via SHA-256 hashing and fixes plan resolution by anchoring to the nearest ancestor directory with planning state, preventing issues when the agent changes directories. The extension supports multiple modes (auto, parity, cache-safe, notify) and includes security measures to ensure plan paths remain within the project root.
.pi/skills/planning-with-files/extensions/planning-with-files · high confidence
Introduce planning-with-files core and DSH plugin adapter
Adds the core logic for the planning-with-files feature, including plan resolution, injection, and gating, and provides a DeepSeek Harness (DSH) plugin entry point that integrates this core with the DSH agent lifecycle. This enables users to manage and inject planning context into DSH sessions, mirroring the functionality available in OpenCode.
.dsh/packages/dsh-planning-with-files/src · high confidence
Introduce planning-with-files plugin for persistent project planning
Adds the planning-with-files plugin (v0.2.2) to Hermes, enabling persistent project planning via slash commands (/pwf, /pwf-status) and tools (planning\_with\_files\_init, planning\_with\_files\_status, planning\_with\_files\_check\_complete). The plugin supports root-mode and isolated slug-based plans, with optional autonomous or gated execution modes, and integrates with Hermes hooks (pre\_llm\_call, post\_tool\_call, pre\_verify) to inject attested plan context and enforce gating. It includes cross-platform path resolution, symlink/junction safety checks, and session isolation to ensure plans are correctly resolved and injected across different environments.
.hermes/plugins/planning-with-files · high confidence
Introduces plan attestation, completion gating, and session initialization scripts
This change adds a suite of shell and PowerShell scripts to the planning-with-files skill to enforce plan integrity and control autonomous execution. The new \attest-plan\ scripts (\.ps1\ and \.sh\) compute and store SHA-256 hashes of \task\_plan.md\ files, allowing hooks to detect and warn on plan tampering. The \check-complete\ scripts implement a configurable 'gate' mode that can block the Stop hook from terminating a session until all phases are marked complete, with logic to handle mixed status formats and ledger-based stall detection. Additionally, \init-session\ scripts now support v3 'autonomous' and 'gated' modes, which automatically apply attestation and nonce generation, while \plan-doctor\ provides a diagnostic tool to verify plan resolution, injection, and attestation status across different install surfaces.
.gemini/skills/planning-with-files/scripts · high confidence
Introduces planning-with-files skill scripts for session initialization, plan resolution, and completion checking
Adds a new set of shell, PowerShell, and Python scripts to the planning-with-files skill to manage the full lifecycle of file-based planning. The init-session scripts (sh/ps1) create the initial task\_plan.md, findings.md, and progress.md files with a structured phase template. The resolve-plan-dir.sh script handles plan directory resolution with support for explicit PWF\_PLAN\_ROOT pinning and session attachment guards. The inject-plan.sh and inject-plan.py scripts provide the core logic for resolving the active plan, verifying attestation, and emitting plan context for injection into the model turn, with the Python version serving as a high-performance single-process alternative to the shell chain. The check-complete scripts (sh/ps1) and gate-stop.sh provide status reporting and termination gating for the Stop hook. The session-catchup.py script analyzes previous sessions to find unsynced context. The set-active-plan scripts manage the .active\_plan pointer with cross-platform support and security containment checks.
.opencode/skills/planning-with-files/scripts · high confidence
Native OpenCode plugin for persistent file-based planning
This location introduces the \opencode-planning-with-files\ plugin, which keeps a disk-based plan (task\_plan.md, findings.md, progress.md) in the model's context on every turn and can hold the session open until the plan reports complete. It supports OpenCode 1.x and 2.x (v2 plugin registration and session lifecycle), injecting the framed planning context via session hooks, appending write reminders after write-like tool executions, preserving the plan pointer and attestation during compaction, and gating gated plans via session idle events. Plan selection honors PLAN\_ID, requires it when several named plans exist, and resolves ambiguity or linked-plan issues; tools pwf\_init, pwf\_status, and pwf\_check are provided. Tests cover core resolution, plugin hooks, and v2 registration.
.opencode/packages/opencode-planning-with-files · high confidence
New 'planning-with-files' skill for persistent, file-based multi-step planning
A new 'planning-with-files' skill has been added to the Hermes adapter, enabling persistent, file-based planning for multi-step AI-agent work. This feature introduces a structured workflow using \task\_plan.md\, \findings.md\, and \progress.md\ to maintain context across sessions. The skill includes lifecycle hooks for automatic recovery, a completion gate for gated/autonomous modes, and scripts for session catch-up and active plan management. It supports multiple IDEs (Claude Code, OpenCode, etc.) and provides templates for both general and analytics-focused tasks.
.hermes · high confidence
New plan attestation and completion gate scripts for cross-platform planning
The \scripts\ directory now includes \attest-plan.ps1\ and \attest-plan.sh\ to cryptographically lock \task\_plan.md\ content with SHA-256 hashes, preventing silent plan tampering by refusing to inject diverged content. Additionally, \check-complete.ps1\, \check-complete.sh\, and \gate-stop.sh\ implement a v3 completion gate that can block autonomous session stops unless specific conditions (like ledger advancement) are met, while \init-session.ps1\ and \init-session.sh\ now support v3 modes (\--autonomous\, \--gated\) that automatically apply these attestation and gate configurations. A new \inject-plan.py\ provides a high-performance, single-process alternative to the shell-based injection chain, specifically optimized to resolve timeout issues on Windows Git Bash environments.
.cursor/skills/planning-with-files/scripts · high confidence
New plan attestation, completion gate, and session initialization scripts
Added new shell and PowerShell scripts to the planning-with-files skill: \attest-plan\ (\.ps1\/\.sh\) computes and stores a SHA-256 hash of the active \task\_plan.md\ to detect tampering; \check-complete\ (\.ps1\/\.sh\) and \gate-stop\ (\.sh\) implement a v3 completion gate that can block the Stop hook when phases are incomplete, based on explicit opt-in via a \.mode\ file, a block counter, and ledger checks; \init-session\ (\.ps1\/\.sh\) now supports v3 modes (\--autonomous\, \--gated\) that write \.mode\ markers, generate nonces, and auto-attest plans, while preserving legacy root-level behavior. These scripts introduce plan attestation, a configurable completion gate, and v3 mode initialization to the planning workflow.
.pi/skills/planning-with-files/scripts · high confidence
New plan attestation, completion gate, and v3 autonomous/gated modes
The scripts in this directory have been replaced with new implementations that introduce plan attestation, a completion gate, and v3 autonomous/gated modes. The new \attest-plan.sh\ and \attest-plan.ps1\ scripts compute and store SHA-256 hashes of \task\_plan.md\ to detect tampering, with PowerShell using native Windows APIs to safely handle reparse points and symlinks. The \check-complete.sh\ and \check-complete.ps1\ scripts now support a \--gate\ (or \-Gate\) mode that can block the Stop hook if specific conditions are met, such as in-progress phases and a \.mode\ file containing 'gate'. The \init-session.sh\ and \init-session.ps1\ scripts now support \--autonomous\ and \--gated\ flags to enable these modes, which also generate nonces for delimiter framing. Additionally, \inject-plan.py\ provides a high-performance Python implementation of the plan injection logic to reduce fork overhead on Windows, and \gate-stop.sh\ acts as a dispatcher for the completion gate.
skills/planning-with-files/scripts · high confidence
New planning scripts for session initialization, completion gating, and plan attestation
The \scripts\ directory now includes \init-session.ps1\ and \init-session.sh\ to create isolated planning sessions (slug mode) and support v3 opt-in modes (\--autonomous\, \--gated\) that enable plan attestation and nonce generation. \check-complete.ps1\ and \check-complete.sh\ provide a completion status report and a new 'gate' mode that can block the Stop hook if specific conditions (like in-progress phases) are met. \attest-plan.ps1\ and \attest-plan.sh\ allow users to lock a plan's content with a SHA-256 hash to detect tampering. \resolve-plan-dir.ps1\ and \resolve-plan-dir.sh\ handle plan directory resolution with improved slug validation and containment checks. \plan-doctor.sh\ is a new diagnostic tool to verify the health of the planning setup.
.continue/skills/planning-with-files/scripts · high confidence
New planning session scripts and cross-platform completion checks
This change introduces a suite of new shell and PowerShell scripts for the planning-with-files skill, including init-session, check-complete, gate-stop, resolve-plan-dir, inject-plan, ledger-summary, session-catchup, and set-active-plan. These scripts provide the core logic for initializing planning files (task\_plan.md, findings.md, progress.md), resolving active plan directories with cross-platform path normalization and security containment guards, injecting plan context into model turns, and reporting completion status via the Stop hook. The addition of check-complete.sh and check-complete.ps1 enables the Stop hook to verify phase completion across all supported environments, while the new Python-based inject-plan.py and session-catchup.py scripts offer optimized, single-process alternatives to the shell-based reference implementations for improved performance on Windows. The gate-stop.sh script acts as a dispatcher for the v3 completion gate, ensuring consistent behavior for autonomous and gated modes.
.mastracode/skills/planning-with-files/scripts · high confidence
Plan attestation, completion gating, and hook body updates for v2.40
This release introduces SHA-256 attestation for plans to detect tampering, an opt-in completion gate to block stopping while phases are in progress, and updated hook bodies that resolve plan directories by slug before falling back to the root plan. The \attest-plan\ scripts (PowerShell and shell) lock plan content hashes, while \check-complete\ scripts enforce the new gate logic. A helper script updates hook bodies across all IDE skill variants, and a version-bumping script ensures parity across all plugin manifests and skill files.
scripts · high confidence
Planning scripts rewritten for cross-platform reliability and v3 autonomous gating
The planning scripts in this directory have been completely rewritten to fix cross-platform issues (particularly on Windows with PowerShell and Git Bash) and to introduce v3 autonomous and gated planning modes. Key changes include: 1) New \attest-plan.ps1\ and \attest-plan.sh\ scripts that use native Windows APIs to safely handle reparse points (symlinks/junctions) and prevent plan tampering via SHA-256 hashing. 2) \check-complete.ps1\ and \check-complete.sh\ now support a \--gate\ mode that blocks task completion unless specific conditions are met (opt-in via \.mode\ file, in-progress phases, etc.), with improved phase counting that handles mixed status formats. 3) \init-session.ps1\ and \init-session.sh\ now support \--autonomous\ and \--gated\ flags to enable v3 modes, which write \.mode\ markers, generate nonces for secure delimiter framing, and auto-attest plans. 4) \inject-plan.py\ provides a high-performance Python implementation of the plan injection logic, replacing the shell-based fork-heavy approach to avoid timeouts on Windows. 5) \gate-stop.sh\ acts as a dispatcher for the completion gate. All scripts now properly resolve plan directories using slug modes, handle ambiguous plans, and respect explicit selectors as bindings rather than hints.
.factory/skills/planning-with-files/scripts · high confidence
Planning scripts rewritten for cross-platform reliability and v3 autonomous/gated modes
The planning-with-files scripts (attest-plan, check-complete, init-session, inject-plan) have been rewritten to ensure cross-platform parity and introduce v3 autonomous and gated planning modes. The new init-session scripts support slug-mode plan directories and opt-in autonomous/gated modes, which write .mode markers, nonces, and auto-attestations. The check-complete scripts now implement a v3 completion gate that can block task completion based on a .mode file, in-progress phases, and a block counter, while also fixing phase counting to handle mixed status formats and avoiding false positives for unstructured plans. The attest-plan scripts provide SHA-256 attestation with robust symlink/junction handling on Windows. The inject-plan.py script replaces the shell-based injection chain to significantly reduce fork overhead and improve performance, especially on Windows.
.codebuddy/skills/planning-with-files/scripts · high confidence
Session-scoped plan binding for planning-with-files
The planning-with-files plugin now supports binding a specific plan to a user session. A new module introduces context-local storage to track the active plan per session, ensuring that plan selections are isolated and do not leak between conversations. This change enables the system to persist and retrieve the correct plan context for each individual session, improving reliability when managing multiple concurrent planning tasks.
python · high confidence
Behavioural changes
1 commit (0 fixes) modifying examples/boxlite
A change to existing behaviour in examples/boxlite — 1 commit, 2 files: “feat: BoxLite sandbox runtime integration (Issue \#84)” (refs \#84).
examples/boxlite · medium confidence · unverified
12 commits (1 fix) modifying .qoder-plugin
A change to existing behaviour in .qoder-plugin — 12 commits (1 fix), 3 files: “fix(qoder): isolate hook execution and honor CLI stop decisions”; “release: v3.24.2 suppress repeated Pi plan reminders”; “release: v3.26.0 add opt-in subagent isolation and repair hooks”; and 9 more.
.qoder-plugin · medium confidence · unverified
4 commits (1 fix) modifying examples/file-only-recovery
A change to existing behaviour in examples/file-only-recovery — 4 commits (1 fix), 10 files: “fix: preserve inconclusive recovery trial receipts”; “docs: clarify compaction recovery and preserve trial receipts”; “docs(recovery): add native PowerShell setup and grading for the fixture”; and 1 more.
examples/file-only-recovery · medium confidence · unverified
Fixes
Enforce consistent line endings for scripts and assets
The repository now uses .gitattributes to ensure shell, Python, and PowerShell scripts are always checked out with LF line endings, while Windows batch files use CRLF. This prevents silent hook failures on platforms where CRLF in a shebang line breaks execution, and ensures binary assets like images are handled correctly.
(repo-wide) · high confidence
Planning scripts rewritten for cross-platform reliability and v3 security features
The planning scripts in .codex/skills/planning-with-files/scripts have been completely rewritten to fix cross-platform compatibility issues (particularly on Windows/PowerShell) and introduce v3 security and workflow features. Key changes include: 1) Plan attestation via SHA-256 hashing (attest-plan.ps1/sh) to detect plan tampering, 2) A completion gate system (check-complete.ps1/sh, gate-stop.sh) that can block autonomous stops based on phase status and ledger activity, 3) v3 mode support (autonomous/gated) in init-session scripts with nonce generation and automatic attestation, 4) Improved plan resolution logic that properly handles symlinks, junctions, and reparse points, 5) A new Python-based inject-plan.py for performance on Windows, 6) Better error reporting for explicit plan selectors, and 7) Support for mixed status formats in phase counting.
.codex/skills/planning-with-files/scripts · high confidence
Test coverage
Added tests for Pi extension plan attestation, anchor resolution, and runtime handlers; Added tests for plan resolution and plugin behavior; Expanded test coverage for planning system stability and security.
Dependencies
Add native plugins for DeepSeek Harness, OpenCode, and Pi Coding Agent
This change introduces three new npm packages that provide native plugin support for the 'planning-with-files' capability across different AI coding environments. The DeepSeek Harness plugin (dsh-planning-with-files) adds per-turn plan injection, write reminders, compaction recovery, and a turn-stopping completion gate. The OpenCode plugin (opencode-planning-with-files) provides similar per-turn injection, write reminders, compaction flush, and a session-idle completion gate. The Pi Coding Agent extension (planning-with-files-pi-extension) integrates the planning logic into the Pi environment. Each package includes its own dependencies and build configuration, establishing the foundational infrastructure for these platform-specific integrations.
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 72 → 68 (-4.9)
- Rubric changed (rubric-2026.11.2 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 70 → 58 (-11.4)
- Architecture 93 → 100 (+7.3)
- Maturity 74 → 78 (+3.8)
- Readiness 67 → 63 (-3.8)
- Security 90 → 90 (+0.0)
- Performance 100 → 100 (+0.0)
Resolved (47)
- Duplicated block (22 lines × 2) (.hermes/skills/planning-with-files/scripts/session-catchup.py)
- Duplicated block (23 lines × 15) (.agents/skills/planning-with-files/scripts/inject-plan.py)
- Duplicated block (25 lines × 15) (.agents/skills/planning-with-files/scripts/inject-plan.py)
- Duplicated block (49 lines × 15) (.agents/skills/planning-with-files/scripts/inject-plan.py)
- Duplicated block (5 lines × 2) (.opencode/skills/planning-with-files/scripts/session-catchup.py)
- FileTooLong: scripts/inject-plan.py (scripts/inject-plan.py)
- FileTooLong: scripts/session-catchup.py (scripts/session-catchup.py)
- High CVE: [GHSA redacted] (.opencode/packages/opencode-planning-with-files/package-lock.json)
- High CVE: [GHSA redacted] (.opencode/packages/opencode-planning-with-files/package-lock.json)
- Injector._run (cognitive 205) (scripts/inject-plan.py)
- Injector._run (cyclomatic 120) (scripts/inject-plan.py)
- Injector.prepare_ledger_snapshot (cognitive 23) (scripts/inject-plan.py)
- Injector.prepare_ledger_snapshot (cyclomatic 16) (scripts/inject-plan.py)
- Medium CVE: [GHSA redacted] (.opencode/packages/opencode-planning-with-files/package-lock.json)
- Medium CVE: [GHSA redacted] (.opencode/packages/opencode-planning-with-files/package-lock.json)
- Medium CVE: [GHSA redacted] (.opencode/packages/opencode-planning-with-files/package-lock.json)
- Medium CVE: [GHSA redacted] (.opencode/packages/opencode-planning-with-files/package-lock.json)
- Near-duplicate member family (10 members, 17 shared lines) (.agents/skills/planning-with-files/scripts/session-catchup.py)
- Near-duplicate member family (15 members, 50 shared lines) (.agents/skills/planning-with-files/scripts/session-catchup.py)
- Near-duplicate member family (15 members, 74 shared lines) (.agents/skills/planning-with-files/scripts/inject-plan.py)
- …and 27 more
New (23)
- Edited copies of one member (3 members, 12+ corresponding lines) (scripts/bump-version.py)
- Edited copies of one member (3 members, 4+ corresponding lines) (.hermes/skills/planning-with-files/scripts/session-catchup.py)
- Edited copies of one member (4 members, 71+ corresponding lines) (skills/i18n/planning-with-files-ar/scripts/session-catchup.py)
- Edited copy of a member (114 corresponding lines) (.hermes/skills/planning-with-files/scripts/session-catchup.py)
- Edited copy of a member (13 corresponding lines) (.hermes/plugins/planning-with-files/paths.py)
- Edited copy of a member (14 corresponding lines) (.hermes/skills/planning-with-files/scripts/session-catchup.py)
- Edited copy of a member (22 corresponding lines) (.opencode/skills/planning-with-files/scripts/session-catchup.py)
- Edited copy of a member (23 corresponding lines) (.codex/hooks/permission_request.py)
- Edited copy of a member (4 corresponding lines) (.codex/hooks/context_frame.py)
- Edited copy of a member (40 corresponding lines) (.hermes/skills/planning-with-files/scripts/session-catchup.py)
- Edited copy of a member (42 corresponding lines) (.hermes/skills/planning-with-files/scripts/sync-ide-folders.py)
- Edited copy of a member (72 corresponding lines) (.hermes/skills/planning-with-files/scripts/sync-ide-folders.py)
- High CVE: [GHSA redacted] (.opencode/packages/opencode-planning-with-files/package-lock.json)
- High CVE: [GHSA redacted] (.opencode/packages/opencode-planning-with-files/package-lock.json)
- Low CVE: [GHSA redacted] (.pi/skills/planning-with-files/extensions/planning-with-files/package-lock.json)
- Medium CVE: [GHSA redacted] (.opencode/packages/opencode-planning-with-files/package-lock.json)
- Medium CVE: [GHSA redacted] (.opencode/packages/opencode-planning-with-files/package-lock.json)
- Medium CVE: [GHSA redacted] (.opencode/packages/opencode-planning-with-files/package-lock.json)
- Medium CVE: [GHSA redacted] (.opencode/packages/opencode-planning-with-files/package-lock.json)
- Medium CVE: [GHSA redacted] (.opencode/packages/opencode-planning-with-files/package-lock.json)
- …and 3 more
Changes since last survey
- 37 commits — 24 feature/other, 13 fixes
By area
- (root) — 10 commits
- skills/i18n — 10 commits
- .agents/skills — 4 commits
- docs/claude-code-lost-context-after-compaction.md — 3 commits
- tests/test_planning_disabled_optout.py — 3 commits
- tests/test_attest_plan_powershell.py — 2 commits
- tests/test_file_only_recovery_grader.py — 2 commits
- examples/file-only-recovery — 1 commit
- scripts/build-npm-readme.py — 1 commit
- tests/test_npm_readme.py — 1 commit
Notable commits
- fix: fix(#357): handle -Help and unknown switches in init-session.sh
- fix: fix(attest-plan): close the review gaps before merge
- fix: fix(attest-plan): correct the previous review commit
- fix: fix(attest-plan): fail closed on unreadable selected plan
- fix: fix(attest-plan): keep root target case-sensitive
- fix: fix(attest-plan): preserve selector failure cause
- fix: fix(attest-plan): report rejected root bindings
- fix: fix(init-session): print help for -? under Windows PowerShell 5.1
- fix: fix(init-session): refuse unknown switches; add -Help on PowerShell
- fix: fix: align localized /plan commands with plan selection and the initializer
- fix: fix: isolate npm README checks from the checkout version
- fix: fix: report attestation resolution failures precisely
- fix: revert: restore the original README
- change: docs(#19): add FAQ for multi-step tasks nearing compaction limit
- change: docs(#19): replace em dashes per docs style test
- change: docs(pi): build the npm README for the packaged release
- change: docs(recovery): add native PowerShell setup and grading for the fixture
- change: docs: add approved Swiftproxy sponsor placement
- change: docs: add compact Evomi sponsor placement
- change: docs: align PreCompact guidance with current host behavior
- …and 17 more
Architecture
- Unchanged — 0 containers · 1 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
OthmanAdi/planning-with-files was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 16 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 51bf62def62d1cb317d37936929b4ef97cf862c3 — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.73+preprod-52de90b74216.