@popovych.co/witness 0.19.3 → 0.19.4

package/README.md

@@ -200,7 +200,7 @@ the wrong file refuses. There are no `WITNESS_*` env vars for configuration.
 | `ship <plan-id> [--manual]` | lanes → ship gate → PR → CI watch → under autonomy: merge on green · `--manual` keeps that run's stop and merge for a human |
 | `test-evidence` / `verify-red` | journal red/green criteria evidence from a worktree |
 | `adopt <path>` | absolve a finished hand-edit into the journal |
-| `abandon <plan-id \| effort-slug>` | wind a plan/effort down; reverts only specs that effort itself wrote |
+| `abandon <plan-id \| effort-slug…>` | wind a plan/effort down; reverts only specs that effort itself wrote — several efforts go as one act, so a split or an amendment they share goes back together |
 | `dispatch-report <plan-id> --steps-assigned <n> --steps-completed <n>` | journal a session slice's telemetry |
 | `rename <old> <new>` | id rename across canon, refs, journal |
 | `clean` | reap stale worktrees |

package/dist/abandon.js

@@ -58,12 +58,32 @@ const shaAt = (root, rev, rel) => {
 // D168 (review). Whether this effort's abandon left its write standing — kept, because a plan
 // stood on it or on a sibling slice, or the walk stopped at it. That content is canon of record:
 // no later walk goes past it, or an amendment on top of it took the keep with it.
-function stoodAtAbandon(root, effort, rel, sha) {
+export function stoodAtAbandon(root, effort, rel, sha) {
     const at = journalActs(root, effort, 'HEAD').find(({ entry }) => entry.t === 'human-decision' && entry.decision === 'abandon-effort');
     return at !== undefined && shaAt(root, at.commit, rel) === sha;
 }
 // This effort's newest write of an artifact (of this content, when `sha` is given).
 export const effortWrite = (root, effort, id, sha) => journalActs(root, effort, 'HEAD').filter(({ entry }) => isWrite(entry, id, sha)).at(-1);
+// D190 (review). The effort whose standing write a take-back stopped at, over some write of
+// `effort` that the take-back neither went past nor found already taken back — the write would
+// stay in canon with its effort abandoned. A write under content that stands for good (shipped by
+// a plan outside the set, or left standing by its own effort's abandon) has nothing left to take.
+export function leftUnder(root, canon, spec, effort, walk, abandonSet) {
+    const id = String(spec.meta.id);
+    const stop = walk.stop === undefined ? undefined : writeAct(root, id, walk.stop.sha, walk.stop.src);
+    const forGood = walk.stop !== undefined && (plansOn(canon, id, { exclude: abandonSet, pin: walk.stop.sha }).some((p) => String(p.meta.status) === 'done') ||
+        (stop !== undefined && effortAbandoned(readStream(root, stop.effort)) && stoodAtAbandon(root, stop.effort, spec.rel, walk.stop.sha)));
+    for (const { entry, commit } of journalActs(root, effort, 'HEAD')) {
+        if (!isWrite(entry, id) || walk.passed.includes(commit))
+            continue;
+        if (takenBackAlready(root, effort, id, spec.rel, String(entry.sha)))
+            continue;
+        if (forGood)
+            continue;
+        return stop?.effort ?? 'another write';
+    }
+    return undefined;
+}
 // D168 (review). Whether an earlier abandon already took this effort's newest write of a spec
 // back — `abandon <plan>` does, before the effort's own abandon: a status entry the abandon
 // journaled on the spec after that write, which is not a return, made where the spec stood at
@@ -95,8 +115,9 @@ export function abandonLines(items, kept) {
 }
 // D166 (review). The efforts whose writes the way back takes back besides this abandon's own
 // targets: every effort already abandoned — whose abandon skipped a spec a later re-slice had
-// departed — and the effort being abandoned now (`effort`, absent on the plan path).
-const goneEfforts = (root, effort) => effortStreams(root).filter((e) => e === effort || effortAbandoned(readStream(root, e)));
+// departed — and the efforts being abandoned now (`efforts`, absent on the plan path; D190:
+// several, when they are abandoned as one act).
+const goneEfforts = (root, efforts) => effortStreams(root).filter((e) => (efforts ?? []).includes(e) || effortAbandoned(readStream(root, e)));
 // Content whose act is a write of one of `efforts` never comes back into canon on its own —
 // unless a plan outside the abandon set stands on it (the keep rule, which never takes shipped
 // content back), or that effort's own abandon left it standing.
@@ -108,9 +129,10 @@ function takenBackBy(root, canon, abandonSet, efforts) {
         return act !== undefined && efforts.includes(act.effort) && !stoodAtAbandon(root, act.effort, rel, sha) ? act : undefined;
     };
 }
-// `act`: the write of `pin` this abandon takes back — the effort's own on the effort path, the
-// write the plan is paired with on the plan path. `effort`: the effort being abandoned, if any.
-export function specRevertFor(root, canon, spec, pin, abandonSet, act, effort) {
+// `act`: the write of `pin` this abandon takes back — on the effort path the write that is the
+// spec's content, by one of the efforts being abandoned (`efforts`); on the plan path the write
+// the plan is paired with.
+export function specRevertFor(root, canon, spec, pin, abandonSet, act, efforts) {
     const current = canonicalSha(spec.meta, spec.body);
     if (current !== pin) {
         return refuse([v('spec', 'stacked-amendment', `${String(spec.meta.id)} is at ${current.slice(0, 7)}, pin is ${pin.slice(0, 7)}`, 'abandon newest-first: a later amendment touched this spec')]);
@@ -131,7 +153,7 @@ export function specRevertFor(root, canon, spec, pin, abandonSet, act, effort) {
     // this spec it made: a revise round re-writes, and taking back only the last write left the
     // effort's own first draft in canon. The walk goes back past those and past every abandoned
     // effort's write, and stops at content a plan stands on.
-    const gone = goneEfforts(root, effort);
+    const gone = goneEfforts(root, efforts);
     const walking = [...new Set([...gone, act.effort])];
     const back = takeBack(root, spec.rel, id, act, takenBackBy(root, canon, abandonSet, walking));
     if (back.end === 'lost') {
@@ -141,7 +163,7 @@ export function specRevertFor(root, canon, spec, pin, abandonSet, act, effort) {
     // another plan still building stands on it, is a keep of that effort's content: the same keep
     // the first round alone would have been, and refused for the same reason — this abandon is the
     // last act that could take it back. Once a plan shipped it, it stands for good.
-    if (effort !== undefined && back.end === 'content') {
+    if (efforts !== undefined && back.end === 'content') {
         const sha = canonicalSha(back.doc.meta, back.doc.body);
         const on = plansOn(canon, id, { exclude: abandonSet, pin: sha });
         const owner = on.length > 0 ? writeAct(root, id, sha, back.src) : undefined;
@@ -163,12 +185,12 @@ export function specRevertFor(root, canon, spec, pin, abandonSet, act, effort) {
     // good when a plan shipped it — and then so does this keep, since nothing can take the
     // sibling back. Every spec the walk passes through counts: each was a re-slice being taken back.
     // D188: on the plan path, also a slice whose own write departed nothing — another slice's
-    // write took the predecessor out. Its effort is still live, and its own abandon is the act that
-    // takes the split back together; deleting the slice now left the split half described. The
-    // effort path is that last act, and there a slice another effort cut cannot go back together
-    // with this one: holding it would leave two efforts' abandons each refusing for the other's.
+    // write took the predecessor out. Its effort is still live, and that effort's abandon is the act
+    // that takes the split back together. On the effort path a hold would tie this abandon to the
+    // other slices' efforts, and row 190's review found that no single act frees every such hold
+    // (an effort with shipped work cannot be abandoned; an adopted slice has no effort at all).
     const own = spec.meta.supersedes === undefined ? undefined : String(spec.meta.supersedes);
-    const slice = effort === undefined && back.end === 'create' && own !== undefined && canonExit(readStream(root, own))?.to === 'superseded' ? [own] : [];
+    const slice = efforts === undefined && back.end === 'create' && own !== undefined && canonExit(readStream(root, own))?.to === 'superseded' ? [own] : [];
     const cut = new Set([...returns.map((r) => r.entry.artifact), ...unwound.map((u) => u.artifact), ...slice]);
     const slices = canon.docs
         .filter((d) => d.meta.type === 'spec' && cut.has(String(d.meta.supersedes)) && String(d.meta.id) !== id)
@@ -176,7 +198,8 @@ export function specRevertFor(root, canon, spec, pin, abandonSet, act, effort) {
         const id = String(d.meta.id);
         const leaving = abandonSet.has(id);
         const on = plansOn(canon, id, leaving ? { exclude: abandonSet, pin: canonicalSha(d.meta, d.body) } : { exclude: abandonSet });
-        return leaving && on.length === 0 ? [] : [{ id, shipped: on.some((p) => String(p.meta.status) === 'done') }];
+        // D190: a slice stamped live is shipped behavior whether or not a plan of it is on file.
+        return leaving && on.length === 0 ? [] : [{ id, shipped: String(d.meta.status) === 'live' || on.some((p) => String(p.meta.status) === 'done') }];
     });
     if (slices.length > 0) {
         return ok({ doc: spec, action: 'keep', standing: slices.map((s) => s.id), shipped: slices.some((s) => s.shipped) });
@@ -192,7 +215,7 @@ export function specRevertFor(root, canon, spec, pin, abandonSet, act, effort) {
         // D166. The unwind departs the spec through the same door the re-slice uses, so
         // everything that leaves canon with a spec — its design included — leaves here too.
         return ok({
-            doc: spec, action: 'delete', returns, unwound,
+            doc: spec, action: 'delete', returns, unwound, walk: { passed: back.passed.map((w) => w.commit) },
             departure: prepareDeparture(root, canon.paths, spec, {
                 v: 1, t: 'status', artifact: id, from: String(spec.meta.status), to: 'removed', cause: 'abandon',
             }),
@@ -204,7 +227,9 @@ export function specRevertFor(root, canon, spec, pin, abandonSet, act, effort) {
     const designR = designRel(canon.paths, id);
     const priorDesign = gitBlob(root, back.src, designR);
     const design = priorDesign !== undefined || existsSync(join(root, designR)) ? { rel: designR, prior: priorDesign } : undefined;
-    return ok({ doc: spec, action: 'restore', content: back.blob.toString('utf8'), toStatus, design, returns, unwound });
+    const stopSha = back.end === 'content' ? canonicalSha(back.doc.meta, back.doc.body) : undefined;
+    const walk = { passed: back.passed.map((w) => w.commit), ...(stopSha === undefined ? {} : { stop: { src: back.src, sha: stopSha } }) };
+    return ok({ doc: spec, action: 'restore', content: back.blob.toString('utf8'), toStatus, design, returns, unwound, walk });
 }
 // D167. A return lands on the path its spec left from, and `rename` moves an id but leaves its
 // file, so another doc may hold that path — or another spec this abandon brings back may have
@@ -232,9 +257,18 @@ export function returnCollisions(root, canon, items) {
 // back only beside what it depends on: a dependency in canon that this abandon does not take
 // out, or one it brings back. `write` refuses a dangling `depends`, and an abandon landing one
 // left `check` red after it exited 0. Bringing the dependency back first is a human's call.
-export function landingEdges(root, canon, items) {
+export function landingEdges(root, canon, items, abandonSet = new Set()) {
     const leaving = new Set(items.flatMap((i) => (i.revert?.action === 'delete' ? [String(i.revert.doc.meta.id)] : [])));
     const coming = new Set(items.flatMap((i) => (i.revert?.returns ?? []).map((r) => r.entry.artifact)));
+    const restored = new Set(items.flatMap((i) => (i.revert?.action === 'restore' ? [String(i.revert.doc.meta.id)] : [])));
+    // D190 (review). A doc of the abandon set that this act leaves as it is — kept, or a write an
+    // earlier abandon already took back — stays in canon, so what it depends on may not leave:
+    // `waiting-dependents` reads only docs outside the set, and the act deleted the dependency.
+    const stays = canon.docs
+        .filter((d) => d.meta.type === 'spec' && abandonSet.has(String(d.meta.id)) && !leaving.has(String(d.meta.id)) && !restored.has(String(d.meta.id)))
+        .flatMap((d) => (d.meta.depends ?? []).map(String)
+        .filter((dep) => leaving.has(dep) && !coming.has(dep))
+        .map((dep) => v('spec', 'waiting-dependents', `${String(d.meta.id)} depends on ${dep}`, `${dep} kept while ${String(d.meta.id)} stays in canon — no doc this abandon leaves standing may depend on a spec it deletes`)));
     const lands = items.flatMap((i) => {
         if (!i.revert)
             return [];
@@ -251,7 +285,7 @@ export function landingEdges(root, canon, items) {
         const why = leaving.has(dep) ? 'it leaves with this abandon'
             : exit?.to === 'superseded' ? `it left superseded by ${exit.by ?? 'a successor'}` : 'it left canon';
         return humanCall(v('spec', 'dangling-depends', `${id} depends on ${dep}`, `${dep} in canon when ${id} comes back — ${why} · a human's call`));
-    }));
+    })).concat(stays);
 }
 // D188 (review). A spec kept for good stays in canon with what it depends on: a dependency this
 // abandon would delete is kept beside it, and for good with it. `waiting-dependents` reads only
@@ -276,7 +310,7 @@ export function keepDependencies(items, kept) {
     }
     return { items: walked, kept: held };
 }
-export function executeAbandon(root, ctx, items, effortEntry, subject) {
+export function executeAbandon(root, ctx, items, efforts, subject) {
     const files = new Set();
     const journalMulti = [];
     const stamps = [];
@@ -319,16 +353,17 @@ export function executeAbandon(root, ctx, items, effortEntry, subject) {
             returnEntries.push(...lines);
         }
     }
-    let effortLine;
-    if (effortEntry) {
+    // D190. Each effort the act abandons ends in the same transaction: one terminal entry each.
+    const effortLines = efforts.map((effort) => {
         const entry = {
-            v: 1, t: 'human-decision', gate: 'effort', artifact: effortEntry.effort,
+            v: 1, t: 'human-decision', gate: 'effort', artifact: effort,
             round: 0, decision: 'abandon-effort',
         };
-        effortLine = { stream: effortEntry.effort, line: entryLine(entry) };
-        files.add(journalRel(effortEntry.effort));
-        journalMulti.push(effortLine);
-    }
+        const line = { stream: effort, line: entryLine(entry) };
+        files.add(journalRel(effort));
+        journalMulti.push(line);
+        return line;
+    });
     const lockR = acquireLock(root);
     if (!lockR.ok)
         return lockR;
@@ -360,9 +395,8 @@ export function executeAbandon(root, ctx, items, effortEntry, subject) {
                 appendEntry(root, se.stream, se.entry);
             for (const re of returnEntries)
                 appendEntry(root, re.stream, re.entry);
-            if (effortLine) {
-                appendEntry(root, effortLine.stream, JSON.parse(effortLine.line));
-            }
+            for (const l of effortLines)
+                appendEntry(root, l.stream, JSON.parse(l.line));
             crashPoint(ctx.env, 'abandon-commit');
             const r = stateCommit(root, [...files], subject);
             // D141. `abandon` runs from wherever the human typed it, which may be the very

package/dist/cli.js

@@ -51,7 +51,7 @@ const VERBS = {
 // 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
 const VERB_USAGE = {
-    abandon: 'witness abandon <plan-id | effort-slug>',
+    abandon: 'witness abandon <plan-id | effort-slug…>',
     adopt: 'witness adopt <specs/... | plans/...>.md',
     ask: 'witness ask <text> | --withdraw <id> [--note <why>]',
     calibrate: 'witness calibrate <exact-model-id> [--suite all|reviewers|skills] [--only <name>] [--samples <n>] [--publish]',

package/dist/departure.js

@@ -137,12 +137,18 @@ function returnsThrough(root, paths, commit, chain, takenBack, seen) {
         const reached = walkBack(root, rel, id, { src, blob, doc: parsed.value }, takenBack, seen);
         // A write the walk cannot go past leaves the return where it stood before that write.
         const walked = reached.end === 'lost' ? { ...reached, ...reached.at, end: 'content' } : reached;
+        // D190 (review). Every amendment the walk took back on the way brings back what it folded
+        // in (an amendment with `supersedes`): row 168 left that out, and a shipped spec folded into
+        // a predecessor that a later re-slice departed never came back.
+        const amended = walked.passed.filter((w) => walked.end !== 'create' || w !== walked.act);
+        const folds = amended.map((w) => returnsThrough(root, paths, w.commit, [id], takenBack, seen));
+        const folded = { returns: folds.flatMap((f) => f.returns), unwound: folds.flatMap((f) => f.unwound) };
         if (walked.end === 'create') {
             // That write created it: it stays out — journaled so whether or not anything lies under
             // the create — and what it had departed comes back instead.
             const gone = { v: 1, t: 'status', artifact: id, from: 'superseded', to: 'removed', cause: 'abandon' };
             const under = returnsThrough(root, paths, walked.act.commit, [...chain, id], takenBack, seen);
-            return { returns: under.returns, unwound: [gone, ...under.unwound] };
+            return { returns: [...under.returns, ...folded.returns], unwound: [gone, ...under.unwound, ...folded.unwound] };
         }
         const status = walked.passed.length > 0 ? String(walked.doc.meta.status) : exit.from;
         const design = designRel(paths, id);
@@ -165,8 +171,8 @@ function returnsThrough(root, paths, commit, chain, takenBack, seen) {
                     rel,
                     by: successor,
                     depends: (walked.doc.meta.depends ?? []).map(String),
-                }],
-            unwound: [],
+                }, ...folded.returns],
+            unwound: folded.unwound,
         };
     });
     return { returns: ways.flatMap((w) => w.returns), unwound: ways.flatMap((w) => w.unwound) };

package/dist/verbs/abandon.js

@@ -1,17 +1,18 @@
 import { EXIT } from '../cli.js';
 import { guardTxn } from '../txn.js';
 import { primaryRoot } from '../gitio.js';
-import { findById, loadCanon } from '../scan.js';
+import { findById, loadCanon, plansOn } from '../scan.js';
 import { effortAbandoned, latestRecap, readStream, streamExists } from '../journal.js';
 import { effortWrites } from '../reviewed.js';
 import { canonicalSha } from '../sha.js';
 import { humanCall, renderRefusal, v } from '../refusal.js';
 import { kv } from '../toon.js';
-import { abandonLines, executeAbandon, keepDependencies, landingEdges, planItems, returnCollisions, specRevertFor, takenBackAlready, writeAct } from '../abandon.js';
+import { abandonLines, executeAbandon, keepDependencies, landingEdges, planItems, returnCollisions, specRevertFor, leftUnder, stoodAtAbandon, takenBackAlready, writeAct } from '../abandon.js';
 export async function run(ctx, argv) {
-    const target = argv.find((a) => !a.startsWith('--'));
+    const targets = argv.filter((a) => !a.startsWith('--'));
+    const target = targets[0];
     if (!target) {
-        ctx.err('usage: witness abandon <plan-id | effort-slug>');
+        ctx.err('usage: witness abandon <plan-id | effort-slug…>');
         return EXIT.REFUSED;
     }
     const rootR = primaryRoot(ctx.cwd);
@@ -25,7 +26,16 @@ export async function run(ctx, argv) {
         return blocked;
     const canon = loadCanon(root);
     const doc = findById(canon, target);
+    const plans = targets.filter((t) => findById(canon, t)?.meta.type === 'plan');
+    if (plans.length > 0 && targets.length > 1) {
+        renderRefusal([v('target', 'one-plan', targets.join(' '), 'one plan id — several effort slugs may be abandoned as one act')]).forEach((l) => ctx.err(l));
+        return EXIT.REFUSED;
+    }
     if (doc && doc.meta.type === 'plan') {
+        if (targets.length > 1) {
+            renderRefusal([v('target', 'one-plan', targets.join(' '), 'one plan id — several effort slugs may be abandoned as one act')]).forEach((l) => ctx.err(l));
+            return EXIT.REFUSED;
+        }
         if (String(doc.meta.status) === 'abandoned') {
             ctx.out(kv('abandon', `${target} already abandoned`));
             return EXIT.OK;
@@ -40,7 +50,7 @@ export async function run(ctx, argv) {
             renderRefusal(taken).forEach((l) => ctx.err(l));
             return EXIT.REFUSED;
         }
-        const done = executeAbandon(root, ctx, [itemR.value], undefined, `abandon(${target})`);
+        const done = executeAbandon(root, ctx, [itemR.value], [], `abandon(${target})`);
         if (!done.ok) {
             renderRefusal(done.violations).forEach((l) => ctx.err(l));
             return EXIT.REFUSED;
@@ -49,18 +59,28 @@ export async function run(ctx, argv) {
         abandonLines([itemR.value], []).forEach((l) => ctx.out(l));
         return EXIT.OK;
     }
-    if (streamExists(root, target) && latestRecap(root, target)) {
-        const entries = readStream(root, target);
-        if (effortAbandoned(entries)) {
-            ctx.out(kv('abandon', `${target} already abandoned`));
-            return EXIT.OK;
+    // D190. Several efforts may be abandoned as one act: `abandon <effort> <effort>…` — one
+    // abandon set, one transaction, each spec taken back once. Efforts whose work is tangled — two
+    // amendments of one spec, a spec and another effort's plan building on it — go back together
+    // instead of one command each in the one order that works.
+    const isEffort = (t) => streamExists(root, t) && latestRecap(root, t) !== undefined;
+    if (targets.every(isEffort)) {
+        const efforts = [];
+        for (const t of targets) {
+            if (effortAbandoned(readStream(root, t)))
+                ctx.out(kv('abandon', `${t} already abandoned`));
+            else if (!efforts.includes(t))
+                efforts.push(t);
         }
-        const writes = effortWrites(root, target);
-        const abandonSet = new Set(writes.keys());
+        if (efforts.length === 0)
+            return EXIT.OK;
+        const writesOf = new Map(efforts.map((e) => [e, effortWrites(root, e)]));
+        const ids = [...new Set([...writesOf.values()].flatMap((w) => [...w.keys()]))];
+        const abandonSet = new Set(ids);
         const items = [];
         const problems = [];
         const kept = [];
-        for (const id of writes.keys()) {
+        for (const id of ids) {
             const artifact = findById(canon, id);
             if (!artifact)
                 continue; // already gone (re-slice, earlier abandon)
@@ -68,8 +88,8 @@ export async function run(ctx, argv) {
                 continue;
             if (String(artifact.meta.status) === 'abandoned')
                 continue; // D189: an earlier abandon withdrew it
-            // 'stamp-only': the spec loop below is this path's sole spec revert, pinned on
-            // THIS effort's write sha. A paired revert here would re-derive the owner and
+            // 'stamp-only': the spec loop below is this path's sole spec revert, from the write
+            // that is the spec's content. A paired revert here would re-derive the owner and
             // could land on a sibling effort's amendment — see Pairing in abandon.ts.
             const itemR = planItems(root, canon, artifact, abandonSet, 'stamp-only');
             if (!itemR.ok) {
@@ -78,29 +98,56 @@ export async function run(ctx, argv) {
             }
             items.push(itemR.value);
         }
-        for (const [id, w] of writes) {
+        for (const id of ids) {
             const artifact = findById(canon, id);
             if (!artifact || artifact.meta.type !== 'spec')
                 continue;
-            // D168. The effort's write is what this abandon takes back only while it is the act the
+            // D168. An effort's write is what this abandon takes back only while it is the act the
             // spec's content is — the same bytes written again later are the later effort's. A write
             // an earlier abandon already took back (`abandon <plan>`) leaves nothing here to take.
+            // D190: the act may be any of the efforts being abandoned; the spec is taken back once,
+            // from it — and only when every listed effort's write of it lies in that one take-back.
             const current = canonicalSha(artifact.meta, artifact.body);
             const act = writeAct(root, id, current);
-            if (current !== w.sha || act?.effort !== target) {
-                if (takenBackAlready(root, target, id, artifact.rel, w.sha))
+            const writers = efforts.filter((x) => writesOf.get(x).has(id));
+            if (act === undefined || !efforts.includes(act.effort)) {
+                // D190 (review). Content that stands for good — shipped by a plan, or left standing by
+                // its own effort's abandon — is canon of record: a write under it has nothing of its own
+                // left to take back, where it refused a stacked amendment no abandon could clear.
+                const shippedOn = plansOn(canon, id, { exclude: abandonSet, pin: current }).filter((p) => String(p.meta.status) === 'done');
+                const recorded = act !== undefined && effortAbandoned(readStream(root, act.effort)) && stoodAtAbandon(root, act.effort, artifact.rel, current);
+                if (shippedOn.length > 0 || recorded) {
+                    kept.push({ doc: artifact, action: 'keep', shipped: true, standing: shippedOn.length > 0 ? shippedOn.map((p) => String(p.meta.id)) : [act.effort] });
                     continue;
-                problems.push(current === w.sha && act === undefined
-                    ? humanCall(v('spec', 'pin-unresolvable', id, `${target}'s journaled write of this content — the journal's history is unreadable here · a human's call`))
-                    : v('spec', 'stacked-amendment', id, 'the effort\'s write is no longer the newest'));
+                }
+                for (const e of writers) {
+                    const w = writesOf.get(e).get(id);
+                    if (takenBackAlready(root, e, id, artifact.rel, w.sha))
+                        continue;
+                    problems.push(current === w.sha && act === undefined
+                        ? humanCall(v('spec', 'pin-unresolvable', `${id} — ${e}'s write`, `${e}'s journaled write of this content — the journal's history is unreadable here · a human's call`))
+                        : v('spec', 'stacked-amendment', `${id} — ${e}'s write`, `abandon newest-first — the effort's write is no longer the newest${act === undefined ? '' : ` · ${act.effort} wrote on top of it`}`));
+                }
                 continue;
             }
-            const revertR = specRevertFor(root, canon, artifact, w.sha, abandonSet, act, target);
+            const revertR = specRevertFor(root, canon, artifact, current, abandonSet, act, efforts);
             if (!revertR.ok) {
                 problems.push(...revertR.violations);
                 continue;
             }
             const outcome = revertR.value;
+            // A take-back that stopped at another effort's standing write leaves every listed write
+            // under it in canon: that effort would end abandoned with its write still there.
+            if (outcome !== undefined && outcome.action !== 'keep') {
+                const buried = writers.flatMap((e) => {
+                    const over = leftUnder(root, canon, artifact, e, outcome.walk, abandonSet);
+                    return over === undefined ? [] : [v('spec', 'stacked-amendment', `${id} — ${e}'s write`, `abandon newest-first — the effort's write is no longer the newest · ${over} wrote on top of it`)];
+                });
+                if (buried.length > 0) {
+                    problems.push(...buried);
+                    continue;
+                }
+            }
             if (outcome?.action === 'keep') {
                 // D166. This abandon is the effort's last act, so a keep here must be one nothing has
                 // to take back later: a shipped plan makes it so — canon describes built behavior. A
@@ -116,20 +163,21 @@ export async function run(ctx, argv) {
                 items.push({ revert: outcome });
         }
         const held = keepDependencies(items, kept);
-        problems.push(...returnCollisions(root, canon, held.items), ...landingEdges(root, canon, held.items));
+        problems.push(...returnCollisions(root, canon, held.items), ...landingEdges(root, canon, held.items, abandonSet));
         if (problems.length > 0) {
             renderRefusal(problems).forEach((l) => ctx.err(l));
             return EXIT.REFUSED;
         }
-        const done = executeAbandon(root, ctx, held.items, { effort: target }, `abandon(${target})`);
+        const done = executeAbandon(root, ctx, held.items, efforts, `abandon(${efforts.join(' ')})`);
         if (!done.ok) {
             renderRefusal(done.violations).forEach((l) => ctx.err(l));
             return EXIT.REFUSED;
         }
-        ctx.out(kv('abandoned', `effort ${target} — ${held.items.length} artifacts walked · journal remembers the attempt`));
+        ctx.out(kv('abandoned', `${efforts.length === 1 ? 'effort' : 'efforts'} ${efforts.join(' · ')} — ${held.items.length} artifacts walked · journal remembers the attempt`));
         abandonLines(held.items, held.kept).forEach((l) => ctx.out(l));
         return EXIT.OK;
     }
-    renderRefusal([v('target', 'unknown-target', target, 'a plan id or an effort slug')]).forEach((l) => ctx.err(l));
+    const unknown = targets.length === 1 ? targets : targets.filter((t) => !isEffort(t));
+    renderRefusal(unknown.map((t) => v('target', 'unknown-target', t, targets.length === 1 ? 'a plan id or an effort slug' : 'an effort slug — several are abandoned as one act'))).forEach((l) => ctx.err(l));
     return EXIT.REFUSED;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@popovych.co/witness",
-  "version": "0.19.3",
+  "version": "0.19.4",
   "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.19.3",
+  "version": "0.19.4",
   "author": {
     "name": "Kostiantyn Popovych"
   },

package/plugin/commands/witness.md

@@ -12,7 +12,7 @@ Any other words in `$ARGUMENTS` are the human's ask: run `$WITNESS ask "<those w
 Resolve the CLI once:
 
 ```bash
-WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.19.3}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.19.4}"
 ```
 
 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.19.3} 2>/dev/null || true
+${WITNESS_BIN:-npx -y @popovych.co/witness@0.19.4} 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.19.3}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.19.4}"
 ```
 
 - **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.19.3}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.19.4}"
 ```
 
 - **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.19.3}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.19.4}"
 ```
 
 - **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.19.3}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.19.4}"
 ```
 
 - **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.19.3}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.19.4}"
 ```
 
 - **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.19.3}"
+WITNESS="${WITNESS_BIN:-npx -y @popovych.co/witness@0.19.4}"
 ```
 
 - **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.