@popovych.co/witness 0.12.0 → 0.13.0

package/dist/gate.js

@@ -431,6 +431,7 @@ export async function runGate(ctx, gateName, target, flags) {
             ...(dropped.length ? { skipped: dropped } : {}),
             ...(outcome === 'stopped' && standing ? { standing } : {}),
             ...(input.artifactSha ? { artifact_sha: input.artifactSha } : {}),
+            ...(input.diffSha ? { diff_sha: input.diffSha } : {}),
             checks: input.checks,
             ...(verdicts.length ? { verdicts } : {}),
             ...(malformed.length ? { malformed } : {}),

package/dist/gates/implement.js

@@ -10,7 +10,7 @@ import { latestRecap, readStream } from '../journal.js';
 import { findById } from '../scan.js';
 import { changedFiles, changedTestSpecs, diffBase, evidenceForDiff, runRegression, screensDir } from '../evidence.js';
 import { runCriteria } from '../criteria.js';
-import { effortOf, implementReviewedSha } from '../reviewed.js';
+import { diffReviewedSha, effortOf, implementReviewedSha } from '../reviewed.js';
 import { worktreePath } from '../worktree.js';
 import { registerGate } from '../gate.js';
 export function codePromptBody(wt, base, files, header) {
@@ -146,6 +146,8 @@ registerGate({
         return ok({
             class: (recap?.class ?? 'feature'),
             reviewedSha: implementReviewedSha(wt, base, plan),
+            // the diff term of the line above, so a lapse can attribute itself (row 135)
+            diffSha: diffReviewedSha(wt, base),
             artifactSha: canonicalSha(plan.meta, plan.body),
             reviewed: { kind: 'tree', root: wt, files },
             promptBody: codePromptBody(wt, base, files, `### Plan under implementation: ${planId}\n${serializeDoc({ meta: plan.meta, body: plan.body })}`),

package/dist/verbs/next.js

@@ -7,11 +7,11 @@ import { primaryRoot } from '../gitio.js';
 import { findById, loadCanon } from '../scan.js';
 import { designArtifactCurrent, designPending, designUnseen } from '../design.js';
 import { effortAbandoned, effortStreams, latestRecap, readStream } from '../journal.js';
-import { effortOf, effortReviewedSha, effortSpecs, effortWrites, implementReviewedSha, planPairSha } from '../reviewed.js';
+import { diffReviewedSha, effortOf, effortReviewedSha, effortSpecs, effortWrites, implementReviewedSha, planPairSha } from '../reviewed.js';
 import { changedFiles, diffBase, evidenceForDiff, isTestPath } from '../evidence.js';
 import { SESSION_DEFAULT, stagePin } from '../model.js';
 import { handoffLine, relayLine, resolveDriver, resolveJudge } from '../harness.js';
-import { worktreeFlow, worktreePath } from '../worktree.js';
+import { atHome, worktreeFlow, worktreePath } from '../worktree.js';
 import { lazyStamp } from '../stamp.js';
 import { ok, refuse, renderRefusal, v } from '../refusal.js';
 import { kv, rows } from '../toon.js';
@@ -86,20 +86,33 @@ export function authoringOwed(entries, gate, currentSha) {
     const recent = lastDisposition(entries, gate, entries.lastIndexOf(last));
     return recent !== undefined && ['revise', 'revise-upstream'].includes(recent.decision);
 }
-// D75 re-arms a gate whose reviewed sha has moved — under row 96 that is the diff moving
-// or the base moving, no longer any file in the worktree. Correct either way, but the row
-// it produces is a bare `gate implement`, indistinguishable from a CLI stuck on a stale
-// answer. A human who just watched that gate pass reads it as the latter, and
-// with a second session in the worktree answering `ship` the pair looks like a deadlock
-// with no error anywhere. The lapse is a fact the CLI already knows; say it.
-function lapseNote(entries, gate, currentSha) {
+// A cap with its remainder counted, never a silent truncation: a note that lists six of
+// nineteen paths and says so is a report, one that lists six and stops is a wrong answer.
+const LAPSE_PATHS = 6;
+function lapseNote(entries, gate, currentSha, 
+// A THUNK: the cause costs extra git invocations, and `next` runs every turn while a
+// lapse is rare. Nothing below the guards may be paid for on the settled path.
+cause) {
     const last = lastGateRun(entries, gate);
     if (!last || currentSha === undefined || last.reviewed_sha === currentSha)
         return undefined;
     // sha-free: asks "was it ever settled", which is the only thing that can lapse
     if (!gateSettled(entries, gate))
         return undefined;
-    return `${gate} approval lapsed — judged @${last.reviewed_sha.slice(0, 7)}, worktree now @${currentSha.slice(0, 7)} — re-gate to judge the current tree`;
+    const shas = `judged @${last.reviewed_sha.slice(0, 7)}, now @${currentSha.slice(0, 7)}`;
+    const c = cause();
+    if (c === undefined || last.diff_sha === undefined) {
+        return `${gate} approval lapsed — ${shas} — re-gate to judge the current tree`;
+    }
+    if (last.diff_sha === c.diffSha) {
+        return `${gate} approval lapsed — the plan was re-authored, the worktree is unchanged (${shas}) — re-gate to judge the current plan`;
+    }
+    const shown = c.changed.slice(0, LAPSE_PATHS).join(' ');
+    const rest = c.changed.length - LAPSE_PATHS;
+    const paths = c.changed.length === 0
+        ? ''
+        : ` · changed vs base: ${shown}${rest > 0 ? ` (+${rest} more)` : ''}`;
+    return `${gate} approval lapsed — the worktree moved (${shas})${paths} — re-gate to judge the current tree`;
 }
 // Row 105. `appendKind` keys on harness, so a cross-harness run is `fresh` and re-invokes
 // the whole battery — while roundsSinceApprove counts every non-malformed run with no
@@ -220,7 +233,10 @@ export function flowAction(root, cfg, plan, judge) {
     }
     return {
         line: `witness gate implement ${id}`, target: id, ...inWorktree,
-        ...noteOf(lapseNote(entries, 'implement', diffSha), judgeNote(entries, 'implement', judge)),
+        ...noteOf(lapseNote(entries, 'implement', diffSha, 
+        // `files` is the list flowAction already computed above — the cause costs one
+        // hash pass, not a second walk of the diff
+        () => (baseR.ok ? { diffSha: diffReviewedSha(wt, baseR.value), changed: files } : undefined)), judgeNote(entries, 'implement', judge)),
     };
 }
 // How far along a flow is — the drain order when several are actionable. Most-advanced
@@ -724,10 +740,22 @@ export async function run(ctx, argv) {
         ctx.out(kv('note', action.note));
     if (action.block)
         action.block.forEach((l) => ctx.out(l));
+    // Whether this session is already in `home:` is a fact the CLI holds both halves of, so
+    // it answers it here rather than printing the handoff and leaving the comparison to the
+    // model. A `run:` line that cds to the directory it was printed in is row 129's defect —
+    // a rendered command that does not run — and it is what let the engine bounce a human
+    // between two checkouts with nothing changing in between.
+    //
+    // NOT rows 116-118's reverted band-aid. That fix made `next` REFUSE a handoff on a
+    // version-skew diagnosis owned by `check`. This withholds no knowledge and changes no
+    // routing answer: the stage, the target and the home are identical either way, and only
+    // the instruction to a session that is already there stops being printed.
     if (action.home) {
         ctx.out(kv('home', action.home));
-        ctx.out(kv('run', handoffLine(harness, action.home, action.model)));
-        ctx.out(kv('relay', relayLine(harness)));
+        if (!atHome(ctx.cwd, action.home)) {
+            ctx.out(kv('run', handoffLine(harness, action.home, action.model)));
+            ctx.out(kv('relay', relayLine(harness)));
+        }
     }
     return EXIT.OK;
 }

package/dist/worktree.js

@@ -1,5 +1,5 @@
-import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { isAbsolute, join, sep } from 'node:path';
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, writeFileSync, } from 'node:fs';
+import { isAbsolute, join, resolve, sep } from 'node:path';
 import { git, stateDirs, tryGit } from './gitio.js';
 import { ok, refuse, v } from './refusal.js';
 export function worktreesDir(root) {
@@ -24,6 +24,26 @@ export function worktreeFlow(cwd, root) {
     // bare join with no slugification, and doc ids are /^[a-z0-9-]+$/ (dsl.ts).
     return rest.length > 0 && !rest.includes(sep) ? rest : undefined;
 }
+// Whether the session asking is already in `home`. A PATH comparison, not a string one:
+// `primaryRoot` answers with git's physical path (`rev-parse --show-toplevel` resolves
+// symlinks) while `ctx.cwd` is whatever the human typed, and on macOS every `/tmp` and
+// `/var` path is a symlink — so a raw `===` reports a session sitting in its own home as a
+// session that must be relocated, which is the handoff loop this predicate exists to close.
+//
+// realpathSync throws on a path that does not exist; `resolve` is the fallback because a
+// home that is not on disk is not one you are standing in, and the comparison must still
+// answer rather than throw inside `next`'s print block.
+export function atHome(cwd, home) {
+    const real = (p) => {
+        try {
+            return realpathSync(p);
+        }
+        catch {
+            return resolve(p);
+        }
+    };
+    return real(cwd) === real(home);
+}
 export function branchName(planId) {
     return `witness/${planId}`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@popovych.co/witness",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Evidence-gated spec-driven development pipeline for AI coding agents: brainstorm to PR in six stages, where specs are state, plans are motion, and no transition passes without evidence. Drives from Claude Code or Pi.",
   "keywords": [
     "spec-driven-development",

package/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "witness",
   "description": "Spec-driven development with evidence gates: brainstorm → PR through six stages and five gates. Skills author, the pinned witness CLI writes state and witnesses evidence; gates stop where judgment is owed.",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "author": {
     "name": "Kostiantyn Popovych"
   },

package/plugin/commands/witness.md

@@ -10,7 +10,7 @@ The CLI decides, you act. If `$ARGUMENTS` contains `--manual`, append `--manual`
 Resolve the CLI once:
 
 ```bash
-WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.12.0}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.13.0}"
 ```
 
 If the repo has no `witness.config.yaml`, run `$WITNESS init` first (one bootstrap commit), then proceed. If init or any verb refuses on a dirty tree, the human commits or cleans it — **never `git commit` yourself, anywhere, at any stage**: the CLI makes its own state commits, and the ship phase makes the sole code commit.
@@ -20,14 +20,14 @@ If the repo has no `witness.config.yaml`, run `$WITNESS init` first (one bootstr
 Every turn is `witness next`, read, act on the first matching row, repeat:
 
 1. Run `$WITNESS next`.
-2. Read its TOON lines: `next:` (a command line), and optional `stage:`, `target:`, `note:`, `home:` (the directory this action's session belongs in), `run:` (the paste-ready handoff command), `relay:` (how a session continues in a fresh context in the same `home:`). `run:` and `relay:` are rendered by the CLI for the harness you are running on — never rewrite them, never substitute a command you remember.
+2. Read its TOON lines: `next:` (a command line), and optional `stage:`, `target:`, `note:`, `home:` (the directory this action's session belongs in), `run:` (the paste-ready handoff command), `relay:` (how a session continues in a fresh context in the same `home:`). **`run:` and `relay:` are printed only when `home:` is a different session from yours** — the CLI compares it against your cwd, resolving symlinks, so you never make that comparison yourself. `run:` and `relay:` are rendered by the CLI for the harness you are running on — never rewrite them, never substitute a command you remember.
 3. Act on the **first** matching row, then go to 1:
 
 | Signal | Action |
 |---|---|
 | A `choose:` block is printed (`note:` says `N ready — ranked below`) | Several specs are ready and the CLI has ranked them. Render the whole block verbatim and in full — the recommendation, its why, each alternative's when and tradeoff, and the `judge-first:` line — then ask the human which to plan. Then use the `witness-plan` skill with the id they name. Never collapse the block to a bare list of ids: the ranking and its costs are the part they are deciding with. |
 | `next:` names `witness decide` | A gate is stopped and the decision is the human's. Run `$WITNESS decide <gate> <target> --show`, render everything it emits verbatim and in full — the checks, the findings, and its ranked options — and **END YOUR TURN**. Never substitute a command set you remember: it is wrong at the round bound, in the reopened and stale states, and wherever a repair grant is unspent. Never run `--approve`, `--revise` or `--stop` on your own judgment. |
-| `home:` present and ≠ your cwd | This stage belongs to a different session. Print the `run:` line verbatim for the human (if this session is `--manual`-armed, change the argument to `'/witness --manual'`), say that work continues in the fresh session, and **END YOUR TURN**. Never use a stage skill or run the `next:` command from the wrong `home:` — a fresh session is the execution model, and it is the only one. |
+| a `run:` line is printed | This stage belongs to a different session; the CLI already compared `home:` against your cwd. Print the `run:` line verbatim for the human (if this session is `--manual`-armed, change the argument to `'/witness --manual'`), say that work continues in the fresh session, and **END YOUR TURN**. Never use a stage skill or run the `next:` command from the wrong `home:` — a fresh session is the execution model, and it is the only one. A `home:` line with **no** `run:` under it means you are already there: read on and act. |
 | `stage: brainstorm` | Use the `witness-brainstorm` skill. |
 | `stage: decompose` | Use the `witness-decompose` skill with `target` (the effort slug). |
 | `stage: design` | Use the `witness-design` skill with `target` (the spec id). |

package/plugin/hooks/session-dashboard.sh

@@ -3,4 +3,4 @@
 # context). Silent everywhere that isn't a witness repo; failures swallowed:
 # session start must never hang or die on this.
 [ -f witness.config.yaml ] || exit 0
-${WITNESS_BIN:-npx -y @popovych.co/witness@0.12.0} 2>/dev/null || true
+${WITNESS_BIN:-npx -y @popovych.co/witness@0.13.0} 2>/dev/null || true

package/plugin/skills/witness-brainstorm/SKILL.md

@@ -15,7 +15,7 @@ witness: ends in a confirmed scope recap, writes no document. See NOTICE.md. -->
 Resolve the CLI once per session:
 
 ```bash
-WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.12.0}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.13.0}"
 ```
 
 - **Render the CLI's decision output verbatim and in full — every line, unmodified.** Never print a command set you remember; never recompose, reformat, summarise or reorder what the CLI emitted. Which decisions are live, how they rank, and what each costs are the CLI's answers, and they change with the round, the bound, the repair grant and the content sha — a remembered set is wrong in more states than it is right.

package/plugin/skills/witness-decompose/SKILL.md

@@ -10,7 +10,7 @@ description: Slice a witness effort's confirmed recap into vertical spec slices,
 Resolve the CLI once per session:
 
 ```bash
-WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.12.0}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.13.0}"
 ```
 
 - **Render the CLI's decision output verbatim and in full — every line, unmodified.** Never print a command set you remember; never recompose, reformat, summarise or reorder what the CLI emitted. Which decisions are live, how they rank, and what each costs are the CLI's answers, and they change with the round, the bound, the repair grant and the content sha — a remembered set is wrong in more states than it is right.

package/plugin/skills/witness-design/SKILL.md

@@ -16,7 +16,7 @@ No text copied verbatim; the design-critic lens is new material. -->
 Resolve the CLI once per session:
 
 ```bash
-WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.12.0}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.13.0}"
 ```
 
 - **Render the CLI's decision output verbatim and in full — every line, unmodified.** Never print a command set you remember; never recompose, reformat, summarise or reorder what the CLI emitted. Which decisions are live, how they rank, and what each costs are the CLI's answers, and they change with the round, the bound, the repair grant and the content sha — a remembered set is wrong in more states than it is right.

package/plugin/skills/witness-implement/SKILL.md

@@ -15,7 +15,7 @@ tests carry the parent spec's tag in their NAME. See NOTICE.md. -->
 Resolve the CLI once per session:
 
 ```bash
-WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.12.0}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.13.0}"
 ```
 
 - **Render the CLI's decision output verbatim and in full — every line, unmodified.** Never print a command set you remember; never recompose, reformat, summarise or reorder what the CLI emitted. Which decisions are live, how they rank, and what each costs are the CLI's answers, and they change with the round, the bound, the repair grant and the content sha — a remembered set is wrong in more states than it is right.

package/plugin/skills/witness-plan/SKILL.md

@@ -15,7 +15,7 @@ parent's criteria. See NOTICE.md. -->
 Resolve the CLI once per session:
 
 ```bash
-WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.12.0}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.13.0}"
 ```
 
 - **Render the CLI's decision output verbatim and in full — every line, unmodified.** Never print a command set you remember; never recompose, reformat, summarise or reorder what the CLI emitted. Which decisions are live, how they rank, and what each costs are the CLI's answers, and they change with the round, the bound, the repair grant and the content sha — a remembered set is wrong in more states than it is right.

package/plugin/skills/witness-ship/SKILL.md

@@ -15,7 +15,7 @@ model can. See NOTICE.md. -->
 Resolve the CLI once per session:
 
 ```bash
-WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.12.0}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.13.0}"
 ```
 
 - **Render the CLI's decision output verbatim and in full — every line, unmodified.** Never print a command set you remember; never recompose, reformat, summarise or reorder what the CLI emitted. Which decisions are live, how they rank, and what each costs are the CLI's answers, and they change with the round, the bound, the repair grant and the content sha — a remembered set is wrong in more states than it is right.