@pmelab/gtd 29.0.0 → 29.1.1

package/dist/workflows.mjs

@@ -17475,7 +17475,12 @@ ${stateFileRules}
 - Every package with tests has a \`## Tests\` section, one line per
   declared test, copied from the architecture entries:
   \`- unit: \\\`<path>\\\`\` or \`- e2e: \\\`<path>\\\`\`. Chore packages have
-  none
+  none. List every test the package writes or changes; also list an
+  existing test a criterion relies on, marked \`(unchanged)\` —
+  \`- unit: \\\`<path>\\\` (unchanged)\` or
+  \`- e2e: \\\`<path>\\\` (unchanged)\`; list no other untouched test;
+  never mark a file the package also writes or changes — list it once,
+  unmarked; only decompose places the marker
 - Leave everything uncommitted and finish
 `;
 const architectureGateAnswerMessage = () => `This gate stops on every process, even with no open question, so
@@ -17508,15 +17513,26 @@ const packagesItemBuildingPrompt = (pkg) => `${stateFileRules}
   never delete the package file (the declared-tests guard reads it
   after you)
 - The package to implement is \`${pkg}\`
-- First check its acceptance criteria against the current tree —
-  an earlier fix turn may already satisfy them. If **every**
-  criterion is met, implement nothing: write \`.gtd/SATISFIED.md\`
-  with each criterion's concrete evidence (commit, file, or
-  symbol), change nothing else, and finish. Otherwise implement
-  normally and skip that file
+- First check the acceptance criteria against the current tree —
+  an earlier fix turn may already meet them
+- **Every criterion already met in the tree**: write
+  \`.gtd/SATISFIED.md\` with evidence per criterion — commit, file,
+  symbol, issue URL, or command output — and change nothing else
+- **No \`## Tests\` and work outside the tree**: first check it was
+  not already done by an earlier attempt (e.g. an existing issue
+  with the same title via \`gh\`) and reuse that as evidence, or do
+  the work; then write \`.gtd/SATISFIED.md\` with that evidence and
+  change nothing else in the tree
+- **Any other package**: implement normally, write no
+  \`.gtd/SATISFIED.md\`
 - Write the tests the package declares under \`## Tests\` first,
   then the code that makes them pass; the turn is refused unless
-  every declared test is in your diff
+  every declared test is in your diff — except a line marked
+  \`(unchanged)\`, which must exist before the turn and stay
+  untouched — creating, editing or deleting it refuses the turn. If
+  it does not exist yet, or the marker is wrong because the package
+  must change that test, stop without creating it and leave it to
+  a person
 - A declared e2e test is a scenario in the repository's own e2e
   framework for the behaviour its \`## E2E Scenarios\` entry names.
   Word it to fit the existing steps — reuse and generalise them
@@ -17544,7 +17560,16 @@ ${strays.map((path) => `  - \`${displayPath(path)}\``).join("\n")}
 - Introduce no new flag read and add no second read of an existing one:
   every match of \`${pattern}\` may move, never increase in number`;
 const withRules = (rules) => rules === void 0 ? "" : `${rules}\n`;
-const refactorBuildingPrompt = (pkg, strays, pattern, reference, feedback = false) => `${stateFileRules}
+function refactorBuildingPrompt(first, strays, pattern, reference, feedback) {
+	return refactorBuildingPromptOf(typeof first === "string" ? {
+		pkg: first,
+		strays: strays ?? [],
+		pattern: pattern ?? "",
+		reference,
+		feedback
+	} : first);
+}
+const refactorBuildingPromptOf = ({ pkg, strays, pattern, reference, feedback = false }) => `${stateFileRules}
 - The package to implement is \`${pkg}\`; never delete it
 ${feedback ? `- The package carries a \`## Review feedback\` section: a human's review of the
   last refactor. Act on it, within the rules below
@@ -37955,34 +37980,86 @@ const deferNotes = (notes, round) => run("review.defer", deferNotesScript(notes,
 });
 //#endregion
 //#region src/workflows/feature/packages.ts
-const TEST_LINE = /^\s*-\s+(unit|e2e):\s+`([^`]+)`/;
-/** The `## Tests` entries of a package file; malformed lines are ignored. */
+const TEST_LINE = /^-\s+(unit|e2e):\s+`([^`]+)`(.*)$/;
+const MARKER = /^[ \t]+\(unchanged\)(?=\s|$)/i;
+const ITEM = /^\s*-\s/;
+/** The `## Tests` entries of a package file; malformed entries are ignored. */
 const declaredTests = (packageText) => {
 	const found = [];
 	let inTests = false;
-	for (const line of packageText.split("\n")) if (/^##\s/.test(line)) inTests = /^##\s+Tests\s*$/.test(line);
-	else if (inTests) {
-		const match = TEST_LINE.exec(line);
+	let entry;
+	const flush = () => {
+		const match = entry === void 0 ? null : TEST_LINE.exec(entry);
 		if (match) found.push({
 			level: match[1],
-			path: match[2]
+			path: match[2],
+			unchanged: MARKER.test(match[3])
 		});
-	}
+		entry = void 0;
+	};
+	for (const line of packageText.replace(/\r\n?/g, "\n").split("\n")) if (/^##\s/.test(line)) {
+		flush();
+		inTests = /^##\s+Tests\s*$/.test(line);
+	} else if (!inTests) continue;
+	else if (ITEM.test(line)) {
+		flush();
+		entry = line.trim();
+	} else if (entry !== void 0 && /^\s/.test(line) && line.trim() !== "") entry = `${entry} ${line.trim()}`;
+	else flush();
+	flush();
 	return found;
 };
+const diffBucket = (test, status, turn, satisfied) => {
+	if (test.unchanged) {
+		if (turn !== "build") return void 0;
+		if (status === "modified") return "modifiedMarked";
+		return status === "added" ? "addedMarked" : void 0;
+	}
+	return !satisfied && (status === void 0 || status === "deleted") ? "notInDiff" : void 0;
+};
+const treeBucket = (test, status) => {
+	if (read(test.path) !== void 0) return void 0;
+	return test.unchanged && status === "deleted" ? "deletedMarked" : "notInTree";
+};
+const unmetBucket = (test, change, turn, satisfied) => diffBucket(test, change?.status, turn, satisfied) ?? treeBucket(test, change?.status);
 /**
 * Refuse a build or fix turn unless every test `pkg` declares exists and is in the
 * diff since `since`. The package text is read as of `since`, so a builder
-* editing its own `## Tests` cannot dodge the guard; with `.gtd/SATISFIED.md`
-* written, existing in the tree suffices.
+* editing its own `## Tests` (or adding `(unchanged)`) cannot dodge the guard;
+* with `.gtd/SATISFIED.md` written, or the line marked, existing suffices. The
+* build turn must neither modify nor add a marked test; a fix turn may edit it.
 */
-const requireDeclaredTests = (pkg, since) => {
+const requireDeclaredTests = (pkg, since, turn = "fix") => {
 	const range = changesSince(since);
 	const text = range.get(pkg)?.before ?? read(pkg) ?? "";
 	const satisfied = read(".gtd/SATISFIED.md") !== void 0;
-	const missing = declaredTests(text).map((test) => test.path).filter((path) => satisfied ? read(path) === void 0 : range.get(path) === void 0 || range.get(path)?.status === "deleted" || read(path) === void 0);
-	if (missing.length === 0) return;
-	refuse(`gtd land: declared-tests: ${pkg} declares tests that are ${satisfied ? "missing from the tree" : "not in the package's diff"} — write them first:\n${missing.map((path) => `  - ${path}`).join("\n")}`);
+	const buckets = {
+		notInDiff: [],
+		modifiedMarked: [],
+		addedMarked: [],
+		deletedMarked: [],
+		notInTree: []
+	};
+	const entries = declaredTests(text);
+	const seen = /* @__PURE__ */ new Set();
+	for (const test of entries) {
+		if (test.unchanged && entries.some((e) => !e.unchanged && e.path === test.path)) continue;
+		const bucket = unmetBucket(test, range.get(test.path), turn, satisfied);
+		if (bucket && !seen.has(test.path)) {
+			seen.add(test.path);
+			buckets[bucket].push(test.path);
+		}
+	}
+	const { notInDiff, modifiedMarked, addedMarked, deletedMarked, notInTree } = buckets;
+	const reasons = [
+		["not in the package's diff — write them", notInDiff],
+		["marked (unchanged) but modified — revert them", modifiedMarked],
+		["marked (unchanged) but added by this turn — the marker promises an existing test; stop and leave it to a person", addedMarked],
+		["marked (unchanged) but deleted — restore them", deletedMarked],
+		["missing from the tree", notInTree]
+	].filter(([, paths]) => paths.length > 0);
+	if (reasons.length === 0) return;
+	refuse(`gtd land: declared-tests: ${pkg} declares tests this turn left unmet:\n${reasons.map(([reason, paths]) => `${reason}:\n${paths.map((path) => `  - ${path}`).join("\n")}`).join("\n")}`);
 };
 /**
 * Build `pkg`, check its declared tests, keep the full suite green, and close
@@ -37990,12 +38067,12 @@ const requireDeclaredTests = (pkg, since) => {
 */
 const packageItem = async (pkg) => {
 	const from = head$1();
-	const declared = (turn) => async () => {
+	const declared = (turn, kind) => async () => {
 		await turn();
-		requireDeclaredTests(pkg, from);
+		requireDeclaredTests(pkg, from, kind);
 	};
-	await declared(() => build(pkg))();
-	await healthy(declared(fixSuite));
+	await declared(() => build(pkg), "build")();
+	await healthy(declared(fixSuite, "fix"));
 	await run("closing", removeScript([
 		pkg,
 		".gtd/SATISFIED.md",
@@ -38230,8 +38307,15 @@ const review$1 = (base, escalations = { rounds: 0 }, options = {}) => {
 		}
 	});
 };
-/** The build tail: fix (when entered red), keep green unless `green`, the quality lap, then human review since `base`. */
-const buildTail = (fixFirst, base, green = false, options = {}) => tail(fixFirst, (escalations) => review$1(base, escalations, options), green, options.guard, options.lenses, options.guardRests, options.lensBase, options.rules);
+function buildTail(first, second, third = false, fourth = {}) {
+	const base = typeof first === "string" ? first : second;
+	const options = typeof first === "string" ? second ?? {} : {
+		...fourth,
+		fixFirst: first,
+		green: third
+	};
+	return tail(options.fixFirst ?? false, (escalations) => review$1(base, escalations, options), options.green ?? false, options.guard, options.lenses, options.guardRests, options.lensBase, options.rules);
+}
 /**
 * Undo the human's review-round code edits. A path changed since the human
 * left it is not overwritten; requireRevert names it instead.
@@ -38372,7 +38456,13 @@ const refactorLap = async (p, guard, feedback) => {
 		label: "Deriving the refactor package",
 		file: REFACTOR_PACKAGE
 	});
-	await agentWithSkills("building", refactorBuildingPrompt(REFACTOR_PACKAGE, strays, pattern, reference, feedback !== void 0), {
+	await agentWithSkills("building", refactorBuildingPrompt({
+		pkg: REFACTOR_PACKAGE,
+		strays,
+		pattern,
+		reference,
+		feedback: feedback !== void 0
+	}), {
 		label: "Refactoring",
 		model: coder(),
 		system: builderSystem()
@@ -38428,7 +38518,8 @@ const reviewedRefactor = async (shape, options = {}) => {
 		let collected;
 		for (;;) {
 			await refactorLap(p, guard, collected);
-			const outcome = await buildTail(false, entry, true, {
+			const outcome = await buildTail(entry, {
+				green: true,
 				guard,
 				guardRests: false,
 				lenses: lensesOf(vars.refactorQualityReviews ?? ""),
@@ -38461,20 +38552,27 @@ const naivePass = (rejection) => agentWithSkills("naive", naivePassPrompt(reject
 	model: coder(),
 	system: builderSystem()
 });
-const implement = (reference, tier, amend) => scope("implement", async () => {
-	await agentWithSkills("building", implementBuildingPrompt(reference, tier, amend), {
-		label: "Implementing",
-		model: coder(),
-		system: builderSystem()
+function implement(first, tier, amend) {
+	const options = typeof first === "object" && first !== null ? first : {
+		reference: first,
+		tier,
+		amend
+	};
+	return scope("implement", async () => {
+		await agentWithSkills("building", implementBuildingPrompt(options.reference, options.tier, options.amend), {
+			label: "Implementing",
+			model: coder(),
+			system: builderSystem()
+		});
+		await healthy(() => agentWithSkills("fix.suite.fixing", implementFixPrompt(), {
+			label: "Fixing the check",
+			file: FEEDBACK,
+			model: coder(),
+			system: builderSystem()
+		}));
+		await run("closing", removeScript([REQUIREMENTS]), { label: "Closing out the implementation" });
 	});
-	await healthy(() => agentWithSkills("fix.suite.fixing", implementFixPrompt(), {
-		label: "Fixing the check",
-		file: FEEDBACK,
-		model: coder(),
-		system: builderSystem()
-	}));
-	await run("closing", removeScript([REQUIREMENTS]), { label: "Closing out the implementation" });
-});
+}
 const decide = () => scope("seam", async () => {
 	let rejection;
 	let retries = 0;
@@ -38549,7 +38647,10 @@ const planAndBuild = async (firstBase, firstLap = "first") => {
 		await design(base);
 		await architecture();
 		await packages();
-		const outcome = await buildTail(false, base, true, lap === "first" ? {} : { lap });
+		const outcome = await buildTail(base, {
+			green: true,
+			...lap === "first" ? {} : { lap }
+		});
 		if (outcome.verdict === "signoff") return;
 		await reUnwind(outcome);
 		base = outcome.base;
@@ -38561,8 +38662,14 @@ const naivePlanAndBuild = async (firstBase) => {
 	const tier = riskTierOn() ? recordRisk() : void 0;
 	const seam = await seamBuild(firstBase);
 	await slice("feature", async () => {
-		await implement(seam.reference, tier);
-		await featureFeedback(await buildTail(false, seam.base, true, { lensBase: seam.base }), seam.base);
+		await implement({
+			reference: seam.reference,
+			tier
+		});
+		await featureFeedback(await buildTail(seam.base, {
+			green: true,
+			lensBase: seam.base
+		}), seam.base);
 	});
 };
 const featureFeedback = async (first, lensBase) => {
@@ -38570,8 +38677,12 @@ const featureFeedback = async (first, lensBase) => {
 	while (outcome.verdict === "feedback") {
 		await reUnwind(outcome);
 		await design(outcome.base);
-		await implement(void 0, riskTierOn() ? recordRisk() : void 0, true);
-		outcome = await buildTail(false, outcome.base, true, {
+		await implement({
+			tier: riskTierOn() ? recordRisk() : void 0,
+			amend: true
+		});
+		outcome = await buildTail(outcome.base, {
+			green: true,
 			lap: "feedback",
 			...lensBase === void 0 ? {} : { lensBase }
 		});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "29.0.0",
+  "version": "29.1.1",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {

package/src/workflows/feature/feature.ts

@@ -39,7 +39,7 @@ export const planAndBuild = async (
     await design(base)
     await architecture()
     await packages()
-    const outcome = await buildTail(false, base, true, lap === "first" ? {} : { lap })
+    const outcome = await buildTail(base, { green: true, ...(lap === "first" ? {} : { lap }) })
     if (outcome.verdict === "signoff") return
     await reUnwind(outcome)
     base = outcome.base
@@ -54,9 +54,9 @@ const naivePlanAndBuild = async (firstBase: string): Promise<void> => {
   const tier = riskTierOn() ? recordRisk() : undefined
   const seam = await seamBuild(firstBase)
   await slice("feature", async () => {
-    await implement(seam.reference, tier)
+    await implement({ reference: seam.reference, tier })
     await featureFeedback(
-      await buildTail(false, seam.base, true, { lensBase: seam.base }),
+      await buildTail(seam.base, { green: true, lensBase: seam.base }),
       seam.base,
     )
   })
@@ -68,8 +68,9 @@ const featureFeedback = async (first: ReviewOutcome, lensBase?: string): Promise
     await reUnwind(outcome)
     await design(outcome.base)
     const tier = riskTierOn() ? recordRisk() : undefined
-    await implement(undefined, tier, true)
-    outcome = await buildTail(false, outcome.base, true, {
+    await implement({ tier, amend: true })
+    outcome = await buildTail(outcome.base, {
+      green: true,
       lap: "feedback",
       ...(lensBase === undefined ? {} : { lensBase }),
     })

package/src/workflows/feature/packages.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, describe, expect, it } from "vitest"
-import { installContext, type Change, type StepRequest } from "../../flows/index.js"
-import { declaredTests, packages } from "./packages.js"
+import { installContext, type Change, type Changes, type StepRequest } from "../../flows/index.js"
+import { declaredTests, packages, requireDeclaredTests } from "./packages.js"
 import { fixtureContext } from "../shared/text.fixture.js"
 
 afterEach(() => installContext(undefined))
@@ -16,8 +16,8 @@ describe("declaredTests", () => {
       "- e2e: `spec/a.feature`",
     ].join("\n")
     expect(declaredTests(text)).toEqual([
-      { level: "unit", path: "lib/a.test.ts" },
-      { level: "e2e", path: "spec/a.feature" },
+      { level: "unit", path: "lib/a.test.ts", unchanged: false },
+      { level: "e2e", path: "spec/a.feature", unchanged: false },
     ])
   })
 
@@ -33,7 +33,88 @@ describe("declaredTests", () => {
       "## Notes",
       "- e2e: `spec/other.feature`",
     ].join("\n")
-    expect(declaredTests(text)).toEqual([{ level: "unit", path: "lib/ok.test.ts" }])
+    expect(declaredTests(text)).toEqual([
+      { level: "unit", path: "lib/ok.test.ts", unchanged: false },
+    ])
+  })
+
+  it("marks a whitespace-led, case-insensitive `(unchanged)` ending at a boundary", () => {
+    const text = [
+      "## Tests",
+      "- unit: `a.test.ts` (unchanged)",
+      "- unit: `b.test.ts` extra",
+      "- unit: `c.test.ts` (unchanged)x",
+      "- unit: `f.test.ts` (unchanged) — kept as is",
+      "- unit: `d.test.ts` (Unchanged)",
+      "- e2e: `e.feature` (unchanged)",
+      "- unit: `g.test.ts`\t(unchanged)",
+      "- unit: `h.test.ts`   (unchanged)",
+      "- unit: `i.test.ts`(unchanged)",
+      "- Unit: `j.test.ts` (unchanged)",
+    ].join("\n")
+    expect(declaredTests(text).map((t) => [t.path, t.unchanged])).toEqual([
+      ["a.test.ts", true],
+      ["b.test.ts", false],
+      ["c.test.ts", false],
+      ["f.test.ts", true],
+      ["d.test.ts", true],
+      ["e.feature", true],
+      ["g.test.ts", true],
+      ["h.test.ts", true],
+      ["i.test.ts", false],
+    ])
+  })
+
+  it("never joins a marker across an empty or whitespace-only line", () => {
+    for (const gap of ["\n\n", "\n  \n", "\n\t\n"]) {
+      const text = `## Tests\n- unit: \`a.test.ts\`${gap}  (unchanged)\n`
+      expect(declaredTests(text).map((t) => t.unchanged)).toEqual([false])
+    }
+  })
+
+  it("reads an entry whose path or marker is wrapped, in any line-end style", () => {
+    const forms = [
+      "- unit: `a/long.test.ts` (unchanged)",
+      "- unit:\n  `a/long.test.ts` (unchanged)",
+      "- unit: `a/long.test.ts`\n  (unchanged)",
+      "- unit:\n  `a/long.test.ts`\n  (unchanged)",
+    ]
+    for (const form of forms) {
+      const lf = `## Tests\n${form}\n- e2e: \`b.feature\`\n`
+      const want = [
+        { level: "unit", path: "a/long.test.ts", unchanged: true },
+        { level: "e2e", path: "b.feature", unchanged: false },
+      ]
+      expect(declaredTests(lf)).toEqual(want)
+      expect(declaredTests(lf.replace(/\n/g, "\r\n"))).toEqual(want)
+      expect(declaredTests(lf.replace(/\n/g, "\r"))).toEqual(want)
+    }
+  })
+
+  it("keeps the heading and its entries when an indented marker follows `## Tests`", () => {
+    const text = "## Tests\n  (unchanged)\n- unit: `a.test.ts`\n"
+    expect(declaredTests(text)).toEqual([{ level: "unit", path: "a.test.ts", unchanged: false }])
+  })
+
+  it("never extends an entry across a new item or a heading", () => {
+    const text = [
+      "## Tests",
+      "- unit: `a.test.ts`",
+      "  - unit: `b.test.ts` (unchanged)",
+      "- unit: `c.test.ts`",
+      "## Tests",
+      "  (unchanged)",
+    ].join("\n")
+    expect(declaredTests(text).map((t) => [t.path, t.unchanged])).toEqual([
+      ["a.test.ts", false],
+      ["b.test.ts", true],
+      ["c.test.ts", false],
+    ])
+  })
+
+  it("closes an entry on an unindented line", () => {
+    const text = "## Tests\n- unit: `a.test.ts`\n(unchanged)\n"
+    expect(declaredTests(text).map((t) => t.unchanged)).toEqual([false])
   })
 
   it("returns nothing without a Tests section", () => {
@@ -72,3 +153,216 @@ describe("packages", () => {
     expect(closings[1]).toContain(".gtd/ARCHITECTURE.md")
   })
 })
+
+describe("requireDeclaredTests", () => {
+  const run = (
+    text: string,
+    tree: readonly string[],
+    changes: readonly Change[],
+    satisfied = false,
+    turn: "build" | "fix" | "default" = "build",
+  ) => {
+    const pkg = ".gtd/packages/01-a.md"
+    installContext(
+      fixtureContext(
+        {},
+        {
+          read: (path: string) =>
+            path === pkg
+              ? text
+              : path === ".gtd/SATISFIED.md"
+                ? satisfied
+                  ? "x"
+                  : undefined
+                : tree.includes(path)
+                  ? "x"
+                  : undefined,
+          refuse: (message: string): never => {
+            throw new Error(message)
+          },
+          changesSince: (): Changes => {
+            const list: Change[] = [
+              { path: pkg, status: "modified", before: text, after: text },
+              ...changes,
+            ]
+            return Object.assign(list, {
+              paths: list.map((c) => c.path),
+              get: (path: string) => list.find((c) => c.path === path),
+            })
+          },
+        },
+      ),
+    )
+    let message = ""
+    try {
+      if (turn === "default") requireDeclaredTests(pkg, "c")
+      else requireDeclaredTests(pkg, "c", turn)
+    } catch (error) {
+      message = String(error instanceof Error ? error.message : error)
+    }
+    return { message }
+  }
+  const deleted = (path: string): Change => ({
+    path,
+    status: "deleted",
+    before: "x",
+    after: undefined,
+  })
+
+  it("groups an unwritten unmarked test and a missing marked test in one refusal", () => {
+    const text = [
+      "## Tests",
+      "- unit: `lib/unwritten.test.ts`",
+      "- unit: `lib/gone.test.ts` (unchanged)",
+      "- unit: `lib/kept.test.ts` (unchanged)",
+    ].join("\n")
+    const { message } = run(text, ["lib/kept.test.ts"], [])
+    expect(message).toContain("gtd land: declared-tests:")
+    expect(message).not.toMatch(/satisf/i)
+    const diffAt = message.indexOf("not in the package's diff")
+    const treeAt = message.indexOf("missing from the tree")
+    expect(diffAt).toBeGreaterThanOrEqual(0)
+    expect(treeAt).toBeGreaterThan(diffAt)
+    expect(message.indexOf("  - lib/unwritten.test.ts")).toBeGreaterThan(diffAt)
+    expect(message.indexOf("  - lib/unwritten.test.ts")).toBeLessThan(treeAt)
+    expect(message.indexOf("  - lib/gone.test.ts")).toBeGreaterThan(treeAt)
+    expect(message).not.toContain("kept.test.ts")
+  })
+
+  it("sends a marked deleted test to restore only", () => {
+    const { message } = run("## Tests\n- unit: `a.test.ts` (unchanged)", [], [deleted("a.test.ts")])
+    expect(message).toContain("declares tests this turn left unmet:")
+    expect(message).toContain("marked (unchanged) but deleted — restore them:\n  - a.test.ts")
+    expect(message).not.toContain("missing from the tree")
+    expect(message).not.toContain("write them")
+  })
+
+  it("keeps a marked absent test with no diff change under missing", () => {
+    const { message } = run("## Tests\n- unit: `a.test.ts` (unchanged)", [], [])
+    expect(message).toContain("missing from the tree:\n  - a.test.ts")
+    expect(message).not.toContain("restore")
+  })
+
+  it("keeps an unmarked deleted test under write, or missing once satisfied", () => {
+    const text = "## Tests\n- unit: `a.test.ts`"
+    expect(run(text, [], [deleted("a.test.ts")]).message).toContain(
+      "not in the package's diff — write them:\n  - a.test.ts",
+    )
+    const done = run(text, [], [deleted("a.test.ts")], true).message
+    expect(done).toContain("missing from the tree:\n  - a.test.ts")
+    expect(done).not.toContain("restore")
+  })
+
+  const modified = (path: string): Change => ({
+    path,
+    status: "modified",
+    before: "x",
+    after: "y",
+  })
+
+  it("refuses a marked test the build modified, even with SATISFIED.md", () => {
+    const text = "## Tests\n- unit: `a.test.ts` (unchanged)"
+    for (const satisfied of [false, true]) {
+      const { message } = run(text, ["a.test.ts"], [modified("a.test.ts")], satisfied)
+      expect(message).toContain("marked (unchanged) but modified — revert them:\n  - a.test.ts")
+    }
+  })
+
+  it("lets a fix turn modify a marked test but not delete it", () => {
+    const text = "## Tests\n- unit: `a.test.ts` (unchanged)\n- unit: `b.test.ts` (unchanged)"
+    expect(run(text, ["a.test.ts"], [modified("a.test.ts")], false, "fix").message).toContain(
+      "missing from the tree:\n  - b.test.ts",
+    )
+    expect(run(text, ["a.test.ts"], [modified("a.test.ts")], false, "fix").message).not.toContain(
+      "revert",
+    )
+    const gone = run(text, [], [deleted("a.test.ts"), deleted("b.test.ts")], false, "fix").message
+    expect(gone).toContain("restore them:\n  - a.test.ts\n  - b.test.ts")
+    const clean = "## Tests\n- unit: `a.test.ts` (unchanged)"
+    expect(run(clean, ["a.test.ts"], [modified("a.test.ts")], false, "fix").message).toBe("")
+  })
+
+  it("lets an unmarked entry for the same file win over a marked one", () => {
+    const text = "## Tests\n- e2e: `x.feature`\n- e2e: `x.feature` (unchanged)"
+    expect(run(text, ["x.feature"], [modified("x.feature")]).message).toBe("")
+  })
+
+  const added = (path: string): Change => ({
+    path,
+    status: "added",
+    before: undefined,
+    after: "x",
+  })
+  const addedGroup =
+    "marked (unchanged) but added by this turn — the marker promises an existing test; stop and leave it to a person"
+
+  it("refuses a marked test the build added, as added and never as modified", () => {
+    const { message } = run(
+      "## Tests\n- unit: `a.test.ts` (unchanged)",
+      ["a.test.ts"],
+      [added("a.test.ts")],
+    )
+    expect(message).toContain(`${addedGroup}:\n  - a.test.ts`)
+    expect(message).not.toContain("revert")
+    expect(message).not.toMatch(/delete|restore/i)
+  })
+
+  it("only the build turn refuses an added marked test (turn split, not a fix-turn flow)", () => {
+    const text = "## Tests\n- unit: `a.test.ts` (unchanged)"
+    expect(run(text, ["a.test.ts"], [added("a.test.ts")], false, "fix").message).toBe("")
+  })
+
+  it.each([
+    ["modified", modified("a.test.ts")],
+    ["added", added("a.test.ts")],
+  ] as [string, Change][])("defaults to the fix turn with two arguments (%s)", (_label, change) => {
+    const text = "## Tests\n- unit: `a.test.ts` (unchanged)"
+    expect(run(text, ["a.test.ts"], [change], false, "default").message).toBe("")
+    expect(run(text, ["a.test.ts"], [change], false, "build").message).not.toBe("")
+  })
+
+  it("lets an unmarked entry win over a marked one the build added", () => {
+    const text = "## Tests\n- unit: `a.test.ts`\n- unit: `a.test.ts` (unchanged)"
+    expect(run(text, ["a.test.ts"], [added("a.test.ts")]).message).toBe("")
+  })
+
+  it("lists a duplicated unwritten line once", () => {
+    const text = "## Tests\n- unit: `a.test.ts`\n- unit: `a.test.ts`"
+    const { message } = run(text, [], [])
+    expect(message.split("a.test.ts").length - 1).toBe(1)
+  })
+
+  it("lists a duplicated marked line missing from the tree once", () => {
+    const text = "## Tests\n- unit: `a.test.ts` (unchanged)\n- unit: `a.test.ts` (unchanged)"
+    const { message } = run(text, [], [])
+    expect(message.split("a.test.ts").length - 1).toBe(1)
+  })
+
+  it("orders write, revert, added, restore, missing and never says satisfied", () => {
+    const text = [
+      "## Tests",
+      "- unit: `w.test.ts`",
+      "- unit: `r.test.ts` (unchanged)",
+      "- unit: `m.test.ts` (unchanged)",
+      "- unit: `v.test.ts` (unchanged)",
+      "- unit: `a.test.ts` (unchanged)",
+    ].join("\n")
+    const { message } = run(
+      text,
+      ["v.test.ts", "a.test.ts"],
+      [deleted("r.test.ts"), modified("v.test.ts"), added("a.test.ts")],
+    )
+    const w = message.indexOf("write them")
+    const v = message.indexOf("revert them")
+    expect(v).toBeGreaterThan(w)
+    const ad = message.indexOf("added by this turn")
+    expect(ad).toBeGreaterThan(v)
+    const r = message.indexOf("restore them")
+    expect(r).toBeGreaterThan(ad)
+    const m = message.indexOf("missing from the tree")
+    expect(w).toBeGreaterThan(0)
+    expect(r).toBeGreaterThan(w)
+    expect(m).toBeGreaterThan(r)
+    expect(message).not.toMatch(/satisf/i)
+  })
+})