@popovych.co/witness 0.11.0 → 0.11.1

package/README.md

@@ -216,8 +216,11 @@ pnpm install
 pnpm test           # vitest, in-process CLI against throwaway git repos
 pnpm run typecheck
 pnpm run build
+pnpm run release patch   # bump + stamp pins + commit + tag, in one act — see docs/RELEASING.md
 ```
 
+Releasing is `node scripts/release.mjs <major|minor|patch|x.y.z>` followed by two pushes; the tag push is what publishes. The order is fixed because CI checks the tagged tree, not the intent — [docs/RELEASING.md](docs/RELEASING.md) explains why and what to do if a tag was pushed early.
+
 ## Run economics (operator notes)
 
 Non-load-bearing knobs for the machine that hosts long implement runs — the design

package/dist/gate.js

@@ -96,8 +96,9 @@ export function renderGateRun(ctx, entry, mode, opts = {}) {
 // --approve read as the default at stops with a live blocking finding. The block ranks them.
 // One renderer for all four decision surfaces in this file — a per-site copy is how D119's
 // nine hand-copied exits sets happened, and three of these four sites were among them.
-// `undefined` from `recommend` means no decision exists at this state (stale below the
-// bound, where the only live act is a re-gate); the exits line still answers that.
+// `undefined` from `recommend` means no anchor resolves at this state — stale with no
+// decision pending (reopened, or already revised), where every decide verb refuses with
+// nothing-pending and the exits line's single re-gate act is the whole live set (D131).
 function renderChoices(ctx, gate, target, entries, upstream, stale = false) {
     const d = recommend({ gate, target, entries, upstream, stale });
     if (d)

package/dist/recommend.js

@@ -1,4 +1,4 @@
-import { anchorRecurrence, boundReached, ladderSpent, lastGateRun, notePrefill, repairGranted, roundBudget, roundsSinceApprove, } from './rounds.js';
+import { anchorRecurrence, boundReached, ladderSpent, lastGateRun, notePrefill, pendingDecision, repairGranted, roundBudget, roundsSinceApprove, } from './rounds.js';
 // Commands are emitted raw (D120): `esc` would quote the `--note "…"` argument and the
 // line would paste into a shell as an empty note.
 export function renderDecision(d) {
@@ -99,9 +99,34 @@ export function recommend(ctx) {
             ],
         };
     }
-    // 2 — stale below the bound: no decision exists, the caller renders the re-gate act.
-    if (stale && !atBound)
-        return undefined;
+    // 2 — stale below the bound. Staleness blocks STAMPING, not judging: `--approve` asserts
+    // about current content and `decide` refuses it with `stale-verdict`, while a stop, a
+    // revise and an upstream judge the WORK and are all legal (probed 2026-08-12, all exit 0).
+    // Gated on a pending decision because that is what resolves an anchor: on the reopened
+    // and revised screens every decide verb refuses with `nothing-pending`, and there the
+    // caller's single re-gate act is the honest answer.
+    if (stale && !atBound) {
+        if (pendingDecision(entries, gate) === undefined)
+            return undefined;
+        const nextRound = spent + 1;
+        return {
+            key: 'decide', rule: 'stale-below-bound',
+            // No anchor: the findings describe bytes that no longer exist, and pinning a decision
+            // to one of them would file recurrence against a verdict nothing can still reproduce.
+            options: [
+                opt(`witness gate ${gate} ${target}`, 'root', {
+                    why: `the verdict judged @${last.reviewed_sha.slice(0, 7)} and the content has moved since — no battery has read the current bytes, so every finding above describes a tree that no longer exists`,
+                    tradeoff: `spends round ${nextRound} of ${budget}${nextRound >= budget ? ' — the last before the bound' : ''}`,
+                }),
+                opt(note, 'root', {
+                    when: 'you already know the next edit and want no verdict on this state',
+                    tradeoff: 'spends no round now — the round is spent by the re-gate that follows it',
+                }),
+                ...upAlt('the parent artifact is what is wrong, whatever the current bytes say', 'reopens the parent stage and resets this budget'),
+                stopOpt,
+            ],
+        };
+    }
     const anchors = blockingAnchors(last);
     const primary = anchors[0];
     const recurrence = primary === undefined ? 0 : anchorRecurrence(entries, gate, primary);

package/dist/rounds.js

@@ -175,8 +175,15 @@ export function liveExits(gate, target, entries, stale, upstream) {
         return [`${d} ${[...approve, ...up, ...repair, '--stop'].join(' | ')}`,
             `witness abandon ${target}`].join(' | ');
     }
-    if (stale)
-        return `witness gate ${gate} ${target}`;
+    // Stale removes --approve and nothing else: `decide` refuses that one with `stale-verdict`
+    // because a stamp asserts about current content, while a stop or a revise judges the work.
+    // Both halves are measured (2026-08-12). The pending check is what separates this from the
+    // reopened and revised screens, where no anchor resolves and every decide verb refuses.
+    if (stale) {
+        if (pendingDecision(entries, gate) === undefined)
+            return `witness gate ${gate} ${target}`;
+        return [`witness gate ${gate} ${target}`, `${d} ${[note, ...up, '--stop'].join(' | ')}`].join(' | ');
+    }
     return `${d} ${['--approve', note, ...up, '--stop'].join(' | ')}`;
 }
 // What un-parks a gate stopped under D124. Below the bound a fresh run is the act — the

package/dist/verbs/decide.js

@@ -132,8 +132,8 @@ export async function run(ctx, argv) {
                 ctx.out(kv('note', disposition.note));
         }
         // The surface a human actually reads while deciding, so it is the one that most owes a
-        // ranking rather than a menu. `undefined` is stale below the bound, where no decision
-        // exists and the exits line's single re-gate act is the honest answer.
+        // ranking rather than a menu. `undefined` is stale with no decision pending, where no
+        // act but the re-gate is legal and the exits line already says exactly that (D131).
         const shown = recommend({ gate, target, entries, upstream: upstreamId, stale });
         if (shown)
             renderDecision(shown).forEach((l) => ctx.out(l));
@@ -275,7 +275,13 @@ export async function run(ctx, argv) {
     // `decision` — so the two are directly comparable in a log query. The full command would
     // carry a prefilled note that changes with the findings, which would make two identical
     // recommendations look different.
-    const rec = recommend({ gate, target, entries, upstream: upstreamId, stale: false });
+    const rec = recommend({
+        gate, target, entries, upstream: upstreamId,
+        // The truth, not `false`. The hardcode existed because a stale state produced no rule at
+        // all and the entry's fields would have been empty; with the stale rule in place it only
+        // misattributes — D130's audit was reporting rules that were never rendered.
+        stale: nowSha !== undefined && nowSha !== anchor.reviewed_sha,
+    });
     const recommendedVerb = rec?.options[0]?.command.match(/--(approve|revise|stop)/)?.[1];
     const entry = {
         v: 1, t: 'human-decision', gate, artifact: target, round: anchor.round,

package/dist/verbs/next.js

@@ -256,7 +256,7 @@ function flowBlocked(root, plan, entries) {
 }
 // The upstream artifact a gate's `--revise --upstream` books its reopen against. The gate
 // registry answers this via `gateSpec().upstreamOf`, but `gate.ts` imports THIS module
-// (gate.ts:23), so importing the registry back would close the cycle the codebase keeps
+// (gate.ts:24), so importing the registry back would close the cycle the codebase keeps
 // one-way on purpose — the same edge that moved `liveExits` out of gate.ts into rounds.ts.
 // Tier 2 hand-resolved it inline in three places; this is that derivation named once, and
 // it agrees with the registry by test (exits-line.test.ts pins upstreamOf for all five).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@popovych.co/witness",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "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",
@@ -57,7 +57,8 @@
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",
-    "sync-versions": "node scripts/sync-versions.mjs"
+    "sync-versions": "node scripts/sync-versions.mjs",
+    "release": "node scripts/release.mjs"
   },
   "dependencies": {
     "yaml": "^2.7.0"

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.11.0",
+  "version": "0.11.1",
   "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.11.0}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.11.1}"
 ```
 
 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.

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.11.0} 2>/dev/null || true
+${WITNESS_BIN:-npx -y @popovych.co/witness@0.11.1} 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.11.0}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.11.1}"
 ```
 
 - **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.11.0}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.11.1}"
 ```
 
 - **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.11.0}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.11.1}"
 ```
 
 - **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.11.0}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.11.1}"
 ```
 
 - **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.11.0}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.11.1}"
 ```
 
 - **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.11.0}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.11.1}"
 ```
 
 - **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.