Commit Graph
13 Commits
Author SHA1 Message Date
OthmanAdi 0308a2f819 fix(scripts): a linked plan directory is never selectable, on every shell-family route
PR #271 made the several-plans counters in inject-plan.sh and
resolve-plan-dir.sh skip symlinked and junctioned plan directories, matching
the Hermes plugin. Skipping the link in the counter alone left the selection
paths following it through containment: one real plan plus a newer linked
one counted as one plan and the newest-mtime scan then selected the linked
directory, the mtime guess the #240 rule exists to prevent. The PowerShell
twin reproduced that after the counter port.

The rule now holds end to end in the shell family: resolve-plan-dir.sh,
inject-plan.sh, resolve-plan-dir.ps1 and the Python twin inject-plan.py
refuse a linked plan directory in the PLAN_ID, .active_plan and
newest-mtime branches and never count it. Every shipped copy is synced.

Tests: the sh/py parity suite gains the linked-directory fixture (the twin
contract), and test_unarmed_plan_ambiguity drives both resolvers and both
injectors over a real plan plus a junction or symlink (#270).
2026-09-19 10:43:59 +02:00
Shaun Lin 0bbc43cff3 fix: skip linked plan dirs in ambiguity counts 2026-09-19 10:36:51 +02:00
OthmanAdi ecaf63f689 fix: refuse ambiguous unpinned named plans (#240) 2026-09-08 12:08:09 +02:00
OthmanAdi ec2ec0a796 fix: start hook interpreters in isolated mode
The python - heredocs and -c snippets in inject-plan.sh and
resolve-plan-dir.sh put the current directory first on sys.path, so a
repository carrying its own secrets.py, hashlib.py or ctypes.py had that
file imported by the hook on every prompt, with the hook's privileges.
Every interpreter start in the two scripts now passes -I, in the canonical
skill and in every synced copy.
2026-09-07 09:37:06 +02:00
OthmanAdi 3749f86ac3 fix: bind explicit plan selectors, floor slug modes on the project root, and classify doctor output on the data frame
Three defects reported by Raymond Manaloto (@sortakool), each reproduced on
Windows with Git Bash before any code changed. Two of them let a session work
on a plan nobody selected; the third made the diagnostic that should have
caught them report PASS.

closes #237: an explicit PLAN_ID was a hint, not a binding

resolve_from_env returned 1 both when no selector was set and when the selector
was rejected, so a PLAN_ID of valid slug shape naming no directory fell through
to .active_plan and then to newest-by-mtime. attest-plan.sh locked that other
plan at rc=0 and injection followed it. The guard in attest-plan.sh written for
exactly this case was unreachable, because the resolver never returned empty.
commands/plan-attest.md has promised the opposite since v3.9.0.

A non-empty PLAN_ID now resolves or stops, for every rejection reason: slug
shape (traversal included), naming no directory, or failing containment. An
empty value still means unset, which init-session.sh depends on. The rule went
into every resolver, because they disagreed otherwise: resolve-plan-dir.sh,
resolve-plan-dir.ps1, the inline resolver inside inject-plan.sh, and the
Hermes, OpenCode and Pi plugin resolvers. v3.14.0 had made the two plugin
resolvers fall through to match the shell; that parity was right and its target
was wrong.

Fixing the resolver alone would have moved the bug rather than removed it, so
every consumer was audited. check-complete.sh would have read the root plan's
completion state, which decides whether an autonomous run may stop.
ledger-summary.sh feeds phase counts into autonomous turns. phase-status.sh and
ledger-append.sh write into the directory they pick. The five Codex hooks call
the resolver directly and each fell through to the legacy root, stop.sh and
pre-compact.sh included. All of them now stop on a rejected selector, and the
once-per-turn routes print a notice, because a fail-closed path with no stated
cause would trade a wrong-plan bug for a silent one.

closes #238: a slug plan with no .mode bypassed the project's root .mode

A project makes attestation mandatory by committing a root .mode, a reviewed
project setting. inject-plan.sh read the slug's .mode and never the root's, and
init-session.sh writes no .mode unless --autonomous or --gated was passed, so
init-session.sh <name>, which /plan runs, produced a plan with no attestation
requirement and full injection. The policy was a flag the agent chose at plan
creation.

The root .mode is now a floor. Strictness-raising tokens count from either
file, so a slug may raise and never lower; the one strictness-lowering token,
plan-guard-off, needs the root's agreement. The same floor applies to the
completion gate in check-complete.sh and check-complete.ps1, which read .mode
the same way and had the same bypass, and to the Hermes and OpenCode plugins.
init-session.sh seeds a new slug from the root .mode so the effective policy is
visible in the plan directory, not only in the resolver. With no root .mode
present the effective token set is exactly the slug's, so existing projects are
unchanged.

closes #236: plan-doctor.sh reported PASS on a fully dark-hooks state

The injection check substring-matched five control strings against output that
carries the plan body verbatim inside the BEGIN-PWF-DATA fences. A plan whose
phase line read "fix the false PLAN TAMPERED warning in plan-doctor" reported a
hash mismatch while correctly attested. Worse, the PWF_PLAN_ROOT arm matched a
literal that is not a substring of what inject-plan.sh emits, so the arm was
dead code and execution fell to the success arm: PWF_PLAN_ROOT=/nonexistent
printed "PASS injection: emits plan context (123 bytes)" while nothing was
injected, counting the refusal notice's own bytes as plan context. The file's
own comment four lines above already warned against exactly that.

Classification now branches on the frame. Every refusal path exits before
frame_file runs, so a frame proves injection happened and unframed output is by
construction a notice. The default arm warns, so a reworded or translated
banner degrades noisily instead of silently. The stale literal is corrected
against the emitting echo.

Tests: Python suite 653 to 696, OpenCode Vitest 28 to 34. New files
test_plan_selector_binding.py, test_root_mode_floor.py and
test_plan_doctor_classification.py; new arms in test_resolver_parity.py,
test_resolve_plan_dir.py, test_resolver_plan_root_pin.py and
test_hermes_first_class.py. Five existing tests asserted the fall-through and
were rewritten to assert the refusal, keeping their original security
assertion. Each suite carries a control arm: two first drafts passed on
fixtures that could not have failed, a gate assertion over a plan with every
phase complete and a parallel-write-guard assertion over a plan with nothing
checked to lose.
2026-09-03 00:23:03 +02:00
OthmanAdi 3b358c5be7 fix: restore cross-platform hook portability 2026-08-31 11:22:19 +02:00
OthmanAdi f9086cda91 fix(security): harden planning context isolation 2026-08-29 14:54:53 +02:00
OthmanAdi ef32a32464 fix: resolve the plan against an explicit root and refuse ambiguous shared cwds
Plan resolution was cwd relative with no notion of a thread: PLAN_ID, then
.planning/.active_plan, then the newest plan directory by mtime, every read
taken relative to the process cwd. A Codex thread sitting at a shared parent
such as /workspace therefore saw only the parent's pointer, and the plan of an
unrelated project was injected on every prompt and every matched tool call
while the nested project's own .active_plan was never consulted (#212).

PWF_PLAN_ROOT binds resolution to a project root by absolute path, which a cwd
relative PLAN_ID slug structurally cannot express. A pin that does not resolve
fails closed with a notice rather than falling back to the ambiguous plan the
caller was escaping. Containment is checked against the pin.

When the plan was chosen by a cwd guess (the shared pointer, newest by mtime,
or a legacy root task_plan.md) and a project one directory below carries its
own live plan, nothing is injected and the notice names both escape hatches.
An explicit PLAN_ID, a pin, or an attached session stays authoritative and
skips the check. Detection is one glob at depth one, which is the whole per
fire budget. A nested pointer that is empty or names a deleted directory does
not compete, so an abandoned subproject cannot kill injection at the root.

The session attachment guard from #146 now runs on this route too. It is not
silent: on hosts that never set PWF_SESSION_ID every session is unattached by
construction, so a stale .planning/sessions/ directory would otherwise kill
injection permanently with no symptom, and .planning/ is gitignored so the
state is invisible to review. The notice is turn scoped so it cannot become
per tool call spam.

Also fixed here, both found by the new tests:

- ledger-summary.sh now takes the resolved plan directory as an argument.
  Under a pin it previously re-resolved from the process cwd, so an autonomous
  loop could read the parent's "1/1 complete" while its own pinned plan had an
  open phase. With no plan directory determinable it says so instead of
  reporting a confident 0/0.
- GNU sha256sum prefixes its output line with a backslash when the filename
  needs escaping, which any Windows style pin triggers, so every attested
  pinned plan reported PLAN TAMPERED on every fire.

plan-doctor reports a refusal as its own state with the remedy. It previously
counted the refusal notice as bytes of plan context and printed PASS, so the
one tool a dark user is pointed at gave a green light.

The legacy invariant holds: with no pin, no sessions directory and no nested
competing plan, output is byte identical to the previous release across every
context and mode, verified by diffing captured stdout against HEAD.
2026-08-01 22:04:37 +02:00
OthmanAdi 78a526dc60 fix: normalize Windows-native canonical paths in plan containment guards
A native Windows coreutils build on PATH gives sh a realpath that prints
C:\-style backslash paths. The containment prefix match in
resolve-plan-dir.sh and inject-plan.sh is written with forward slashes,
so every canonical pair mismatched: the resolver resolved nothing and
inject-plan.sh emitted nothing, exit 0, no error. Plan resolution and
hook injection were fully and silently disabled on such machines.

Canonical paths are now backslash-normalized (pure shell, no extra
process) before comparison. The resolver also canonicalizes its root via
"." and checks candidates through their cwd-relative form, healing the
8.3 short-path mismatch the v3.2.0 fix only applied to inject-plan.sh.
Per-candidate grep and basename forks are replaced with case patterns
and parameter expansion; the containment root is computed once per run.

Regression tests use a PATH-prepended stub realpath that reproduces the
backslash output shape on every platform, so Linux CI guards this
Windows-only field failure. Also cures the long-standing local
test_ledger.py hang on Windows.
2026-07-18 11:54:22 +02:00
yolo0731 242a5c95c3 fix: persist secure Codex plan recovery 2026-07-13 07:56:09 +02:00
OthmanAdi 36747b41a4 fix(security): realpath containment and attestation integrity gap
resolve-plan-dir canonicalizes the resolved plan path (realpath,
readlink -f, python fallback; fail-open on minimal shells) and rejects
paths escaping the project root, closing the symlink injection vector.
attest-plan no longer leaves a stale attestation when the atomic
rename fails: fallback write is temp plus rename, then read-back
verification exits nonzero on mismatch. attest-plan --show surfaces
the plan nonce when present.
2026-06-09 21:06:25 +02:00
OthmanAdi 3e35f428f3 release: v2.40.0 (slug-mode resolution fix + perf cache + KV-cache hygiene + Pi false-positive fix)
Bug fixes (items 1-5 in proposal_v2_40.md):

1. Hook resolution order inverted across UserPromptSubmit, PreToolUse, PreCompact.
   Slug-mode now wins over legacy root task_plan.md when both exist. Closes the
   bug where an active .planning/<slug>/ plan was silently bypassed in favor of
   the root file. Resolution chain: PLAN_ID env > .planning/.active_plan >
   newest .planning/<slug>/ by mtime > root fallback.

2. .active_plan target dir is validated. Dead pointers fall through cleanly.

3. .active_plan content is regex-validated as ^[A-Za-z0-9_][A-Za-z0-9._-]*$.
   Whitespace-only and path-traversal corruption fall through instead of
   producing weird path lookups. Tests cover whitespace, ../escape, and
   leading-dot cases.

4. check-complete.sh wires into resolve-plan-dir.sh when no path arg given.
   Restores slug-mode parity for any caller that invokes the script without an
   explicit plan path.

5. Pi extension dangerous-command detection uses word-boundary regex. Benign
   git push origin <branch> no longer triggers the warning; only --force,
   --mirror, +ref, plus rm -rf, sudo, chmod 777/a+rwx, git reset --hard, git
   clean -fd, fork bombs, dd to /dev/[sh]d[a-z].

Performance (items 6, 7):

6. mtime-keyed SHA-256 cache under ${TMPDIR:-/tmp}/pwf-sha cuts redundant hash
   work on warm cache. Caches the result keyed by absolute plan-file path,
   stores mtime + hash, skips sha256sum when mtime unchanged.

7. KV-cache hygiene on injected progress.md tail. Sub-second timestamps and
   timezone-suffix forms are normalized to a stable epoch-zero form so the
   model's prefix cache stays warm across turns. Manus-aligned.

Portability + races (items 19, 20):

19. resolve-plan-dir.sh portable mtime fallback chain: GNU stat -> BSD stat ->
    date -r -> python3 -> python -> perl -> 0. Multi-plan workflows stop
    silently degrading on non-GNU systems.

20. attest-plan.sh uses atomic temp+rename with optional flock guard.
    Concurrent legacy-mode attestations stop producing truncated files that
    triggered false [PLAN TAMPERED] warnings.

Tests: 130 pass / 2 pre-existing Windows exec-bit failures unchanged. +20 new
tests vs v2.39.0. See CHANGELOG for full inventory.

Version bumped to 2.40.0 across 14 SKILL.md variants + plugin.json +
marketplace.json + CITATION.cff via scripts/bump-version.py. .continue,
.gemini, .pi, .kiro lag intentionally.
2026-05-21 23:07:55 +02:00
OthmanAdi 9bf31fc41e release: v2.36.0 (parallel plan isolation + Codex session isolation + Hermes docs)
Closes #146, #147, #148.

Parallel plan isolation (#148, @shawnli1874): init-session.sh slug mode
creates .planning/YYYY-MM-DD-<slug>/ for each task. set-active-plan.sh/.ps1
switch the active plan pointer. resolve-plan-dir.sh/.ps1 provide the
resolution chain ($PLAN_ID env, .active_plan file, newest plan dir, legacy
fallback). All four Codex hooks route through the resolver. resolve_latest_dir
now requires task_plan.md to be present, preventing system dirs like sessions/
from being selected as plan dirs. short_uuid() probes each Python candidate
before trusting command -v, fixing silent failure on Windows Store aliases.

Codex session isolation (#146, @githubYiheng): sessions attach to a plan by
creating .planning/sessions/<session_id>.attached. user-prompt-submit.sh,
pre_tool_use.py, stop.py, and post_tool_use.py all gate on session attachment
before injecting context or blocking. Legacy mode preserved when
.planning/sessions/ does not exist.

Hermes integration notes (#147, @09ashishkapoor): docs/hermes.md gains an
Integration Notes section covering current support level, what is not full
parity with hook-native platforms, recommended integration pattern, and a
tradeoffs table.

34 new tests across five files. Version bumped to 2.36.0 across 14 SKILL.md
variants, plugin.json, marketplace.json, and CITATION.cff.
2026-05-01 18:37:25 +02:00