@popovych.co/witness 0.9.0 → 0.10.0

package/README.md

@@ -117,6 +117,21 @@ witness commits the payload. It refuses the whole run if a payload path carries
 uncommitted change (`payload-dirty`) or if the CLI you are running is older than the
 payload already installed (`cli-behind-payload`).
 
+From **0.10.0** onward `init` installs into **every home of the repository** — the primary
+root and each live `.witness/worktrees/<plan-id>` — because a worktree is a branch
+checkout, so its payload is a different file on a different timeline. A worktree cut
+before an upgrade used to keep the old pin forever, and the old pin is what selects the
+CLI that runs there. Every home is preflighted before any is written, so a dirty payload
+in one refuses the whole run rather than leaving the set half-upgraded, and `witness check`
+now reports `payload-stale` per home and names the stale one.
+
+The same release makes the bound structural: every journal entry records the CLI that
+wrote it, and a CLI older than anything the repository's state has seen refuses every verb
+with `cli-behind-state` rather than answering from rules the repository has moved past.
+`witness floor --show` reports the bound. If you are deliberately rolling back — a bad
+release, say — lower it first with `witness floor --set <version> --note <why>`; the
+decision is journaled, and `floor` is the one verb that still runs under a bound it fails.
+
 ### Support tiers
 
 | Tier | Agents | What they get |

package/dist/cli.js

@@ -1,8 +1,9 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync } from 'node:fs';
 import { configPath } from './config.js';
+import { stateFloor } from './floor.js';
 import { primaryRoot } from './gitio.js';
 import { renderRefusal, v } from './refusal.js';
+import { NPX_LATEST, compareTriple, version } from './version.js';
 export const EXIT = { OK: 0, FINDINGS: 1, REFUSED: 2, BLOCKED: 3 };
 const VERBS = {
     recover: () => import('./verbs/recover.js'),
@@ -33,6 +34,9 @@ const VERBS = {
     rename: () => import('./verbs/rename.js'),
     sync: () => import('./verbs/sync.js'),
     calibrate: () => import('./verbs/calibrate.js'),
+    // Row 116's valve. Exempt from the floor gate in `main`, because a repository that
+    // refuses every verb must still be able to run the one that unrefuses it.
+    floor: () => import('./verbs/floor.js'),
 };
 // answered centrally so no verb can crash on --help (several parse argv
 // strictly); each line mirrors the verb's own usage refusal where one exists
@@ -43,6 +47,7 @@ const VERB_USAGE = {
     check: 'witness check',
     clean: 'witness clean',
     decide: 'witness decide <gate> <target> --approve|--revise|--stop [--override] [--repair] [--note <t>] [--upstream <artifact|effort>] [--pin <policy>]… [--show]',
+    floor: 'witness floor --show | --set <triple> --note <why>',
     design: 'witness design <spec-id> --file <html> | --reconfirm | --open',
     diff: 'witness diff <spec-id>',
     'dispatch-report': 'witness dispatch-report <plan-id> --steps-assigned <n> --steps-completed <n> [--tokens <n>] [--tool-uses <n>] [--duration-ms <n>]',
@@ -62,10 +67,10 @@ const VERB_USAGE = {
     'test-evidence': 'witness test-evidence <plan-id> --phase red|green',
     'verify-red': 'witness verify-red <plan-id> [--base <ref>]',
 };
-export function version() {
-    const pkg = JSON.parse(readFileSync(join(new URL('.', import.meta.url).pathname, '..', 'package.json'), 'utf8'));
-    return pkg.version;
-}
+// Row 116 moved the body to version.ts, which journal.ts can import without closing a
+// cycle. Re-exported here because eleven call sites already ask the CLI shell for it and
+// the question they are asking has not changed.
+export { version };
 export function usage() {
     return [
         'witness — spec-led pipeline: specs are state, plans are motion',
@@ -80,6 +85,38 @@ export async function main(ctx, argv) {
         ctx.out(version());
         return EXIT.OK;
     }
+    // Row 116. Above the verb table on purpose — including above the bare-`witness`
+    // dashboard route, which reads the same state every verb does. The invariant is "one
+    // repository, one witness version", and a per-verb opt-in is a list some future verb
+    // forgets to join.
+    //
+    // This is the guard row 102's `cli-behind-payload` structurally could not be. That one
+    // fires inside the home it protects, so a home frozen at an old pin runs an old CLI that
+    // never learned to check — which is how two sessions a lifecycle apart each computed a
+    // different next stage, each redirected to the other's home, and each honestly ended its
+    // turn. The state is the one thing every home shares, so the state is where the bound
+    // belongs.
+    //
+    // Forward-only, and the text must never imply otherwise: a CLI published before this row
+    // cannot run this code. Homes already frozen are found by `check` and repaired by `init`.
+    //
+    // Two exemptions, both load-bearing. `floor` is how a bad publish is recovered from — a
+    // repository that refuses every verb must still be able to run the one that unrefuses it.
+    // An explicit help request is information, and refusing to print a usage line teaches
+    // the human nothing they can act on.
+    const helpRequested = verb === 'help' || verb === '--help'
+        || rest.includes('--help') || rest.includes('-h');
+    if (!helpRequested && verb !== 'floor') {
+        const gateRoot = primaryRoot(ctx.cwd);
+        if (gateRoot.ok) {
+            const floor = stateFloor(gateRoot.value);
+            if (floor !== undefined && (compareTriple(version(), floor.pin) ?? 0) < 0) {
+                renderRefusal([v('witness', 'cli-behind-state', `this CLI is ${version()}, this repository's state was written by ${floor.pin}`, `a CLI at or ahead of ${floor.pin} — run ${NPX_LATEST} init --agent <name>; if you are `
+                        + `deliberately rolling back, lower the bound first with witness floor --set ${version()} --note <why>`)]).forEach((l) => ctx.err(l));
+                return EXIT.REFUSED;
+            }
+        }
+    }
     if (!verb || verb === 'help' || verb === '--help') {
         if (!verb) {
             const rootRes = primaryRoot(ctx.cwd);

package/dist/floor.js

@@ -0,0 +1,74 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { journalRel } from './journal.js';
+import { compareTriple } from './version.js';
+// Row 116. The state's own answer to "what is the oldest CLI allowed to touch this
+// repository", derived from the `w` stamps entryLine writes and stored nowhere. Derived
+// because a stored floor is a second source of truth that drifts from the entries it
+// summarises — the shape rows 93, 95 and 96 all name — and because a derived one cannot
+// be lowered by editing a file, only by a journaled decision (verbs/floor.ts).
+//
+// MAXIMUM, not most-recent: a downgraded CLI writing a lower stamp after a higher one is
+// exactly the event this guards against, and a floor that fell to the last writer would
+// ratify the regression it exists to refuse.
+//
+// `undefined` means the state carries no readable stamp at all — every repository written
+// before this row shipped. It is silence, not zero: a floor of 0.0.0 would be a claim the
+// state never made, and it would refuse nothing anyway.
+export function stateFloor(root) {
+    const dir = join(root, '.witness', 'journal');
+    if (!existsSync(dir))
+        return undefined;
+    // An explicit decision outranks the derived maximum — including downward, which is the
+    // only reason the verb exists. Latest wins, so a second rollback supersedes the first:
+    // the last decision is the state, the same doctrine D94 applies to gate decisions.
+    const pinned = entries(root, FLOOR_STREAM)
+        .filter((e) => e.t === 'policy-pin' && e.key === FLOOR_KEY && typeof e.pin === 'string')
+        .at(-1);
+    if (pinned !== undefined)
+        return { pin: pinned.pin, stream: 'a human decision' };
+    let best;
+    for (const file of readdirSync(dir).filter((f) => f.endsWith('.jsonl')).sort()) {
+        const stream = file.slice(0, -'.jsonl'.length);
+        for (const e of entries(root, stream)) {
+            if (typeof e.w !== 'string')
+                continue;
+            const pin = e.w;
+            // `compareTriple(pin, pin)` is the parse check: undefined means CANNOT COMPARE, the
+            // same contract install.ts's two guards read it under. A stamp we cannot read must
+            // never raise a bound — that would refuse a legal CLI over a typo.
+            if (compareTriple(pin, pin) === undefined)
+                continue;
+            if (best === undefined || (compareTriple(pin, best.pin) ?? 0) > 0)
+                best = { pin, stream };
+        }
+    }
+    return best;
+}
+// The journal stream a floor decision lives in. Its first entry is a policy-pin, never a
+// recap, so `effortStreams` does not mistake it for an effort.
+export const FLOOR_STREAM = 'floor';
+export const FLOOR_KEY = 'floor';
+// Deliberately NOT journal.ts's readStream, whose bare JSON.parse throws. This runs on
+// EVERY verb now, so one unreadable line would brick the whole CLI — including `floor`
+// itself, the one verb that could unstick it. readStream's strict parse stays right for
+// callers that need the entry; a bound derived from stamps needs only the lines it can
+// actually read, and skipping the rest is the honest reading of a damaged file.
+function entries(root, stream) {
+    const path = join(root, journalRel(stream));
+    if (!existsSync(path))
+        return [];
+    const out = [];
+    for (const raw of readFileSync(path, 'utf8').split('\n')) {
+        if (raw === '')
+            continue;
+        try {
+            out.push(JSON.parse(raw));
+        }
+        catch {
+            // a line we cannot parse carries no decision and no stamp we can trust — the same
+            // answer as a line that never had one
+        }
+    }
+    return out;
+}

package/dist/install.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { version } from './cli.js';
@@ -114,6 +114,45 @@ export function installPayload(root, harness) {
     }
     return ok(out);
 }
+// Row 117. "Upgrade the repository" has always meant "upgrade one checkout of it":
+// installPayload had exactly one call site and it targeted the primary root, so nothing
+// ever refreshed a live worktree. A worktree is a branch checkout, so its payload is a
+// different file on a different timeline — the same property row 87 relies on to get the
+// payload to the agent at all, read the other way round.
+//
+// Root first, then worktrees in sorted order: the root is the home the human is standing
+// in, and if a later home fails they need the report to read top-down.
+export function payloadHomes(root) {
+    const dir = join(root, '.witness', 'worktrees');
+    if (!existsSync(dir))
+        return [root];
+    return [root, ...readdirSync(dir, { withFileTypes: true })
+            .filter((e) => e.isDirectory())
+            .map((e) => join(dir, e.name))
+            .sort()];
+}
+// Preflight EVERY home before writing ANY. install.ts's standing doctrine is that a
+// refusal leaves nothing half-installed; across homes that matters more, not less — a
+// half-upgraded set of homes IS the skew row 116 refuses and this row prevents.
+export function installAllHomes(root, harness) {
+    const homes = payloadHomes(root);
+    const failures = homes.flatMap((home) => {
+        const pre = preflightPayload(home, harness);
+        // Name the home in the field, or a `payload-dirty` row over `.claude/commands/witness.md`
+        // is ambiguous across four checkouts of the same repository.
+        return pre.ok ? [] : pre.violations.map((x) => ({ ...x, field: home === root ? x.field : `${home}: ${x.field}` }));
+    });
+    if (failures.length > 0)
+        return refuse(failures);
+    const out = [];
+    for (const home of homes) {
+        const synced = installPayload(home, harness);
+        if (!synced.ok)
+            return refuse(synced.violations);
+        out.push({ home, synced: synced.value });
+    }
+    return ok(out);
+}
 function hasCommand(entries, command) {
     return (entries ?? []).some((e) => (e.hooks ?? []).some((h) => h.command === command));
 }

package/dist/journal.js

@@ -1,11 +1,18 @@
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
+import { version } from './version.js';
 const dir = (root) => join(root, '.witness', 'journal');
 export const journalRel = (id) => `.witness/journal/${id}.jsonl`;
 export function streamExists(root, id) {
     return existsSync(join(root, journalRel(id)));
 }
-export const entryLine = (entry) => JSON.stringify({ v: 1, ...entry });
+// Row 116. `w` is the CLI that wrote this line. Stamped HERE because entryLine is the
+// single funnel every state write passes through, so one edit covers fourteen entry types
+// and every verb without a widened signature to disagree over. It is what lets the state
+// name its own floor (floor.ts) instead of a stored number that drifts from the entries it
+// summarises — and it is why a repo can refuse a CLI older than its own history without
+// consulting any payload file, which is the guard row 102 structurally could not be.
+export const entryLine = (entry) => JSON.stringify({ v: 1, w: version(), ...entry });
 export function appendEntry(root, id, entry) {
     mkdirSync(dir(root), { recursive: true });
     const line = entryLine(entry);

package/dist/verbs/check.js

@@ -3,7 +3,7 @@ import { join } from 'node:path';
 import { adoptedCommits } from '../adopt.js';
 import { EXIT, version } from '../cli.js';
 import { DEFAULT_HARNESS, HARNESSES, judgeLine, loadHarness, resolveJudge, resolveSkills, skillPins } from '../harness.js';
-import { packageRoot } from '../install.js';
+import { packageRoot, payloadHomes } from '../install.js';
 import { latestPublished } from '../registry.js';
 import { NPX_LATEST, compareTriple } from '../version.js';
 import { probe } from '../probe.js';
@@ -254,14 +254,24 @@ export async function run(ctx, argv = []) {
             // whole suite stays green, because vitest reads from the repo root. installPayload
             // is where that condition refuses (`source-missing`); a diagnostic verb must not
             // crash on it, and must not report the repo as stale for it either.
-            const stale = installed.filter((p) => {
+            //
+            // Row 118: per HOME, not per repository. A worktree is a branch checkout, so its
+            // payload is a different file that can be a different age — and that is exactly the
+            // state row 116's floor cannot see, because the floor binds only CLIs at or after
+            // the version that introduced it while the frozen homes were cut before it. The
+            // root keeps its bare relative path; a worktree is named, or four checkouts of one
+            // repository all report `.claude/commands/witness.md` and the human cannot tell
+            // which of them is the rotten one.
+            const stale = payloadHomes(root).flatMap((home) => installed
+                .filter((p) => {
                 const src = join(packageRoot(), p.from);
-                if (!existsSync(src))
+                if (!existsSync(src) || !existsSync(join(home, p.to)))
                     return false;
-                return readFileSync(join(root, p.to), 'utf8') !== readFileSync(src, 'utf8');
-            });
+                return readFileSync(join(home, p.to), 'utf8') !== readFileSync(src, 'utf8');
+            })
+                .map((p) => (home === root ? p.to : `${home}: ${p.to}`)));
             if (stale.length > 0) {
-                findings.push(f('warn', 'harness', `${name}: payload`, 'payload-stale', `${stale.map((p) => p.to).join(' · ')} differ from what ${version()} ships — run ${NPX_LATEST} init --agent ${name}`));
+                findings.push(f('warn', 'harness', `${name}: payload`, 'payload-stale', `${stale.join(' · ')} differ from what ${version()} ships — run ${NPX_LATEST} init --agent ${name}`));
             }
         }
         const skills = resolveSkills(ctx.env, root, harness);

package/dist/verbs/floor.js

@@ -0,0 +1,49 @@
+import { parseArgs } from 'node:util';
+import { EXIT } from '../cli.js';
+import { FLOOR_KEY, FLOOR_STREAM, stateFloor } from '../floor.js';
+import { primaryRoot } from '../gitio.js';
+import { appendEntry } from '../journal.js';
+import { renderRefusal, v } from '../refusal.js';
+import { kv } from '../toon.js';
+import { compareTriple, version } from '../version.js';
+// Row 116's safety valve. The floor is derived from what the state has seen, which is
+// correct until a published version turns out to be broken: then every repository that ran
+// it once carries a bound no fixed CLI can satisfy, and the tool has locked its users out
+// over its own defect. Lowering it is a human act with a reason, so it is journaled as a
+// policy-pin — the entry type row 83 added for exactly this shape — and never a flag on
+// another verb or a file someone can edit without leaving a trace.
+export async function run(ctx, argv) {
+    const { values } = parseArgs({
+        args: argv,
+        options: { show: { type: 'boolean' }, set: { type: 'string' }, note: { type: 'string' } },
+    });
+    const rootRes = primaryRoot(ctx.cwd);
+    if (!rootRes.ok) {
+        renderRefusal(rootRes.violations).forEach((l) => ctx.err(l));
+        return EXIT.REFUSED;
+    }
+    const root = rootRes.value;
+    if (values.set !== undefined) {
+        // Both faults in one refusal, the way row 111 collects an approve's: a human who fixes
+        // one and learns about the other on the re-run has spent a turn witness could have saved.
+        const violations = [];
+        if (compareTriple(values.set, values.set) === undefined) {
+            violations.push(v('--set', 'bad-pin', values.set, 'a numeric triple such as 0.9.0 — prerelease ordering is out of scope (row 102)'));
+        }
+        if (values.note === undefined || values.note.trim() === '') {
+            violations.push(v('--note', 'note-required', 'absent', 'a reason — lowering the bound is a decision the journal has to be able to explain later'));
+        }
+        if (violations.length > 0) {
+            renderRefusal(violations).forEach((l) => ctx.err(l));
+            return EXIT.REFUSED;
+        }
+        appendEntry(root, FLOOR_STREAM, { t: 'policy-pin', key: FLOOR_KEY, pin: values.set, note: values.note });
+        ctx.out(kv('floor', `${values.set} — set by hand: ${values.note}`));
+        return EXIT.OK;
+    }
+    const floor = stateFloor(root);
+    ctx.out(floor === undefined
+        ? kv('floor', 'none — this state predates the writer stamp, so it claims no bound')
+        : kv('floor', `${floor.pin} · from ${floor.stream} · this CLI is ${version()}`));
+    return EXIT.OK;
+}

package/dist/verbs/init.js

@@ -6,7 +6,7 @@ import { configPath } from '../config.js';
 import { writeDoc } from '../fm.js';
 import { commitWithTrailer, primaryRoot, tryGit } from '../gitio.js';
 import { loadHarness, resolveDriver } from '../harness.js';
-import { installPayload, mergeSettings, preflightPayload, readIfExists, recordHarness, writeSettings, } from '../install.js';
+import { installAllHomes, mergeSettings, preflightPayload, readIfExists, recordHarness, writeSettings, } from '../install.js';
 import { probe } from '../probe.js';
 import { acquireLock } from '../lock.js';
 import { renderRefusal, v } from '../refusal.js';
@@ -119,13 +119,30 @@ export async function run(ctx, argv = []) {
         }
         let synced;
         if (harness !== undefined) {
-            const payload = installPayload(root, harness);
+            const payload = installAllHomes(root, harness);
             if (!payload.ok) {
                 renderRefusal(payload.violations).forEach(ctx.err);
                 return EXIT.REFUSED;
             }
-            synced = payload.value;
+            synced = payload.value.find((p) => p.home === root)?.synced ?? { written: [], overwritten: [] };
             files.push(...synced.written, ...synced.overwritten);
+            // Row 117. Each worktree is a separate checkout on a separate branch, so its payload
+            // can only be committed there — the root's commit below cannot reach it.
+            // commitWithTrailer, not a hand-rolled `commit --only`: `--only` resolves its
+            // pathspec against the index, so a freshly written payload the worktree has never
+            // tracked is "did not match any file(s) known to git" until the add it already does.
+            // It also carries the state-commit trailer and treats a no-op as silent success.
+            for (const { home, synced: s } of payload.value.filter((p) => p.home !== root)) {
+                const touched = [...s.written, ...s.overwritten];
+                if (touched.length === 0)
+                    continue;
+                const committed = commitWithTrailer(home, touched, `init(${harness.name}): agent payloads`);
+                if (!committed.ok) {
+                    renderRefusal(committed.violations).forEach(ctx.err);
+                    return EXIT.REFUSED;
+                }
+                ctx.out(kv('payload-synced', `${home} — ${touched.join(' · ')}`));
+            }
             if (harness.settings !== undefined) {
                 const merged = mergeSettings(readIfExists(root, harness.settings));
                 if (merged.changed) {

package/dist/verbs/recap.js

@@ -5,7 +5,7 @@ import { EXIT } from '../cli.js';
 import { loadConfig } from '../config.js';
 import { ID_RE } from '../dsl.js';
 import { primaryRoot, stateCommit } from '../gitio.js';
-import { appendEntry, effortAbandoned, journalRel, readStream, streamExists } from '../journal.js';
+import { appendEntry, effortAbandoned, entryLine, journalRel, readStream, streamExists } from '../journal.js';
 import { acquireLock } from '../lock.js';
 import { renderRefusal, v } from '../refusal.js';
 import { kv } from '../toon.js';
@@ -120,7 +120,9 @@ export async function run(ctx, argv) {
             t: 'recap', effort: recap.effort, class: recap.class,
             goals: recap.goals, non_goals: recap.non_goals, constraints: recap.constraints, slices: recap.slices,
         };
-        const line = JSON.stringify({ v: 1, ...entry });
+        // entryLine, never a second inline JSON.stringify — completeTxn re-appends when this
+        // marker line differs from what appendEntry wrote, so the two must be one derivation.
+        const line = entryLine(entry);
         const stream = journalRel(recap.effort);
         const res = withTxn(root, { op: `recap(${recap.effort})`, files: [stream], journal: { stream: recap.effort, line } }, () => {
             appendEntry(root, recap.effort, entry);

package/dist/verbs/write.js

@@ -193,7 +193,12 @@ export async function run(ctx, argv) {
             ...(existing === undefined ? { created: true } : {}),
             ...(supersedes !== undefined ? { supersedes } : {}),
         };
-        const line = JSON.stringify({ v: 1, ...entry });
+        // entryLine, never a second inline JSON.stringify: completeTxn decides whether to
+        // re-append by comparing this marker line against the last journal line, so any field
+        // entryLine adds and this does not makes the two differ and the recovery duplicate the
+        // entry. Row 116's `w` stamp is what caught it; the shape is the one rows 93, 95 and
+        // 96 all name, and every other txn writer already calls entryLine.
+        const line = entryLine(entry);
         const supersededDesignRel = reslice ? designRel(cfg.value.paths, reslice.entry.artifact) : undefined;
         const files = [rel, stream,
             ...(reslice ? [reslice.doc.rel, journalRel(reslice.entry.artifact)] : []),
@@ -238,7 +243,7 @@ function journalRefusal(ctx, root, effort, artifact, violations) {
         t: 'write-refused', effort, artifact,
         rules: violations.map(({ field, rule }) => ({ field, rule })),
     };
-    const line = JSON.stringify({ v: 1, ...entry });
+    const line = entryLine(entry);
     const stream = journalRel(effort);
     const res = withTxn(root, { op: `write-refused(${artifact})`, files: [stream], journal: { stream: effort, line } }, () => {
         appendEntry(root, effort, entry);

package/dist/version.js

@@ -1,3 +1,5 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
 // The one home for "which version of witness is which". install.ts parsed the pin to
 // decide whether a payload was only a pin apart (row 102 killed that rule) and check.ts
 // re-declared the same regex inline — one question answered in two places, which is the
@@ -36,3 +38,13 @@ export function compareTriple(a, b) {
 // through a frozen /witness is `npx …@0.5.1 init`, which restamps 0.5.1 onto 0.5.1 — a
 // no-op that reads as compliance. Remedies name the version.
 export const NPX_LATEST = 'npx -y @popovych.co/witness@latest';
+// Row 116. Moved here from cli.ts. `journal.ts` stamps every entry with it and cannot
+// import the CLI shell without closing a cycle (cli → verbs/* → journal). This module
+// already claimed to be the one home for "which version of witness is which" while the
+// reader itself lived in the shell — the same split rows 93, 95 and 96 keep naming. The
+// single readFileSync is the exception to this file's no-I/O rule and the only one it
+// may ever have.
+export function version() {
+    const pkg = JSON.parse(readFileSync(join(new URL('.', import.meta.url).pathname, '..', 'package.json'), 'utf8'));
+    return pkg.version;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@popovych.co/witness",
-  "version": "0.9.0",
+  "version": "0.10.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.9.0",
+  "version": "0.10.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.9.0}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.10.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.

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.9.0} 2>/dev/null || true
+${WITNESS_BIN:-npx -y @popovych.co/witness@0.10.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.9.0}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.10.0}"
 ```
 
 - **Never edit `specs/**` or `plans/**`** (the canon dirs — `paths:` in witness.config.yaml may relocate them) — not with an edit tool, not with a write tool, not with Bash redirection. The CLI is the sole writer of state; you author in scratch files under `$(mktemp -d)` and hand them to the CLI. (The canon guard blocks you; the trailer audit catches what it can't.)

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.9.0}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.10.0}"
 ```
 
 - **Never edit `specs/**` or `plans/**`** (the canon dirs — `paths:` in witness.config.yaml may relocate them) — not with an edit tool, not with a write tool, not with Bash redirection. The CLI is the sole writer of state; you author in scratch files under `$(mktemp -d)` and hand them to the CLI. (The canon guard blocks you; the trailer audit catches what it can't.)

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.9.0}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.10.0}"
 ```
 
 - **Never edit `specs/**`, `plans/**`, or `designs/**`** — the CLI is the sole writer of state. Author HTML in `$(mktemp -d)` and hand it to `witness design`. (The canon guard blocks direct edits; the trailer audit catches end-runs.)

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.9.0}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.10.0}"
 ```
 
 - **Never edit `specs/**` or `plans/**`** (the canon dirs — `paths:` in witness.config.yaml may relocate them) — not with an edit tool, not with a write tool, not with Bash redirection. The CLI is the sole writer of state; you author in scratch files under `$(mktemp -d)` and hand them to the CLI. (The canon guard blocks you; the trailer audit catches what it can't.)

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.9.0}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.10.0}"
 ```
 
 - **Never edit `specs/**` or `plans/**`** (the canon dirs — `paths:` in witness.config.yaml may relocate them) — not with an edit tool, not with a write tool, not with Bash redirection. The CLI is the sole writer of state; you author in scratch files under `$(mktemp -d)` and hand them to the CLI. (The canon guard blocks you; the trailer audit catches what it can't.)

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.9.0}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.10.0}"
 ```
 
 - **Never edit `specs/**` or `plans/**`** (the canon dirs — `paths:` in witness.config.yaml may relocate them) — not with an edit tool, not with a write tool, not with Bash redirection. The CLI is the sole writer of state; you author in scratch files under `$(mktemp -d)` and hand them to the CLI. (The canon guard blocks you; the trailer audit catches what it can't.)