@pmelab/gtd 27.6.0 → 27.7.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gtd",
-  "version": "27.6.0",
+  "version": "27.7.0",
   "description": "Drive the gtd loop inside Claude Code: agent turns run as subagents, gtd decides every beat",
   "author": {
     "name": "Philipp Melab"

package/README.md

@@ -416,7 +416,7 @@ noted in steps 3 and 4 below.
    `gtd judge run --provider jev` asks TypeSafe's Jev instead, with the key in
    `TYPESAFE_API_KEY` and `JEV_BASE_URL` optionally overriding the endpoint;
    `gtd judge run --provider llm` asks the `claude` CLI on `PATH` (Claude Code
-   users only; model `haiku`, `--model <name>` overrides) and reuses its login.
+   users only; model `sonnet`; `--model <name>` overrides) and reuses its login.
    With no `--provider`, `gtd judge run` picks jev when `TYPESAFE_API_KEY` is
    set and non-empty and no `--model` is given, else llm — never falling back
    across them; the `GTD_JUDGE_PROVIDER` / `GTD_JUDGE_MODEL` environment
@@ -431,7 +431,8 @@ noted in steps 3 and 4 below.
 
    gtd itself never calls a judge: `gtd loop`, the Claude Code mod and the
    reference driver answer these through `gtd judge run` (auto selection: jev
-   when `TYPESAFE_API_KEY` is set, else `llm` via `claude`, default model haiku,
+   when `TYPESAFE_API_KEY` is set, else `llm` via `claude`, default model
+   sonnet, while the Claude Code mod's own judge subagent stays on `haiku` —
    `--model <name>` overrides); if that fails it shows you the message and
    stops. **The `llm` provider's `p` is self-reported by the model, not a
    measured probability, so a confidently wrong verdict can clear the 0.7 floor

package/dist/gtd.bundle.mjs

@@ -41695,7 +41695,7 @@ const FLAGS = [
 		help: [
 			"(gtd land, with --cost) tag that cost's model",
 			"(gtd judge run, llm answerer) the claude model; omitted:",
-			"GTD_JUDGE_MODEL, then judge.json, then haiku"
+			"GTD_JUDGE_MODEL, then judge.json, then sonnet"
 		]
 	},
 	{
@@ -42088,7 +42088,7 @@ const COMMAND_ROWS = [
 			"--answers <path> or GTD_JUDGE_ANSWERS; questions the file",
 			"does not cover are left out. --provider jev asks TypeSafe",
 			"(TYPESAFE_API_KEY). --provider llm asks the `claude` CLI",
-			"on PATH (Claude Code only), model haiku unless --model.",
+			"on PATH (Claude Code only), model sonnet unless --model.",
 			"No --provider: GTD_JUDGE_PROVIDER, then ~/.config/gtd/",
 			"judge.json, else jev when TYPESAFE_API_KEY is set and no",
 			"model is given, else llm; --model likewise falls back to",
@@ -58805,7 +58805,7 @@ var DEFAULT_MODEL, TIMEOUT_MS, SYSTEM_PROMPT, fail$1, unreadable, levelsOf, opti
 var init_llm = __esmMin((() => {
 	init_criteria();
 	init_io();
-	DEFAULT_MODEL = "haiku";
+	DEFAULT_MODEL = "sonnet";
 	TIMEOUT_MS = 18e4;
 	SYSTEM_PROMPT = "You are a strict, impartial judge. Answer each question from the supplied evidence alone.\nReply only with the structured answer; never use tools or ask questions.";
 	fail$1 = (message) => {

package/dist/testkit.mjs

@@ -10825,7 +10825,7 @@ const FLAGS = [
 		help: [
 			"(gtd land, with --cost) tag that cost's model",
 			"(gtd judge run, llm answerer) the claude model; omitted:",
-			"GTD_JUDGE_MODEL, then judge.json, then haiku"
+			"GTD_JUDGE_MODEL, then judge.json, then sonnet"
 		]
 	},
 	{
@@ -11218,7 +11218,7 @@ const COMMAND_ROWS = [
 			"--answers <path> or GTD_JUDGE_ANSWERS; questions the file",
 			"does not cover are left out. --provider jev asks TypeSafe",
 			"(TYPESAFE_API_KEY). --provider llm asks the `claude` CLI",
-			"on PATH (Claude Code only), model haiku unless --model.",
+			"on PATH (Claude Code only), model sonnet unless --model.",
 			"No --provider: GTD_JUDGE_PROVIDER, then ~/.config/gtd/",
 			"judge.json, else jev when TYPESAFE_API_KEY is set and no",
 			"model is given, else llm; --model likewise falls back to",
@@ -13076,18 +13076,22 @@ const recognizeGtdUncheck = (repo, block) => {
 * definition) keeps the `@inmem` tier green.
 */
 const recognizeDidNotRunComment = (block) => block === "# gtd emitted this and did NOT run it — pipe it into `sh` to land the turn" ? { kind: "noop" } : void 0;
-/** `combinedScript`'s optional half. ALWAYS reports `noop` whatever the inner result, mirroring bash's `( … ) || <warning>`, where the subshell's exit status is swallowed and must never fail the outer script. */
+/** `combinedScript`'s optional half. Reports `noop` whatever the inner result, mirroring bash's `( … ) || <warning>`. Exception: under `git: false` any unrecognized inner block fails the outer script (git or not), so the in-memory twin knowingly diverges from `sh` rather than run git unseen. */
 const PRESENTATION_FAILURE_TEXT = `${extractQuotedTokens(PRESENTATION_FAILURE_WARNING)[0].replace(/\\n$/, "")}\n`;
 const PRESENTATION_SUBSHELL_PREFIX = `${PRESENTATION_ONLY_COMMENT}\n(\n`;
 const PRESENTATION_SUBSHELL_SUFFIX = `\n) || ${PRESENTATION_FAILURE_WARNING}`;
-const recognizePresentationSubshell = (repo, commands, block) => {
+const recognizePresentationSubshell = (repo, commands, block, git) => {
 	if (!block.startsWith(PRESENTATION_SUBSHELL_PREFIX) || !block.endsWith(PRESENTATION_SUBSHELL_SUFFIX)) return;
 	const inner = block.slice(PRESENTATION_SUBSHELL_PREFIX.length, block.length - PRESENTATION_SUBSHELL_SUFFIX.length);
-	const result = applyEmittedScript(repo, commands, inner);
+	const result = applyEmittedScript(repo, commands, inner, { git });
 	if (result.ok) return {
 		kind: "noop",
 		output: result.output
 	};
+	if (!git && result.error?.startsWith(UNRECOGNIZED_PREFIX)) return {
+		kind: "failed",
+		error: `${result.output}${result.error}`
+	};
 	return {
 		kind: "noop",
 		output: `${result.output}${PRESENTATION_FAILURE_TEXT}`
@@ -13194,17 +13198,17 @@ const recognizeWriteLines = (repo, block) => {
 	return { kind: "applied" };
 };
 /** Every recognizer `applyEmittedScript` tries, first match wins — `recognizeScriptedCommand` stays last since it's the exact-hit fallback for anything the rest don't claim. */
-const recognizersFor = (repo, commands) => [
+const recognizersFor = (repo, commands, git) => [
 	(block) => recognizeSetFlags(block),
 	(block) => recognizeDidNotRunComment(block),
 	(block) => recognizePrecondition(repo, block),
 	(block) => recognizeFileExistsGuard(repo, block),
 	(block) => recognizeBinaryGuard(commands, block),
-	(block) => recognizeGitBuilders(repo, block),
+	(block) => git ? recognizeGitBuilders(repo, block) : void 0,
 	(block) => recognizeDeferNotes(repo, block),
 	(block) => recognizeWriteLines(repo, block),
 	(block) => recognizeFailurePromptWrapper(repo, commands, block),
-	(block) => recognizePresentationSubshell(repo, commands, block),
+	(block) => recognizePresentationSubshell(repo, commands, block, git),
 	(block) => recognizeModeContradictionSkipNotice(block),
 	(block) => recognizeModeContradictionCheck(repo, commands, block),
 	(block) => recognizeGtdCheck(repo, block),
@@ -13227,7 +13231,7 @@ const recognizeBlock = (recognizers, block) => {
 * non-zero scripted-command exit — exactly like `set -euo pipefail` stops a
 * real script. No block after the failing one is applied.
 */
-const applyEmittedScript = (repo, commands, script) => {
+const applyEmittedScript = (repo, commands, script, { git = true } = {}) => {
 	const flow = applyFlowScript(repo, commands, script);
 	if (flow !== void 0) return flow.ok ? {
 		ok: true,
@@ -13239,10 +13243,10 @@ const applyEmittedScript = (repo, commands, script) => {
 		output: flow.output,
 		error: flow.error ?? ""
 	};
-	return script.startsWith("#!") ? unrecognized(script) : applyBlocks(repo, commands, script);
+	return script.startsWith("#!") ? unrecognized(script) : applyBlocks(repo, commands, script, git);
 };
-const applyBlocks = (repo, commands, script) => {
-	const recognizers = recognizersFor(repo, commands);
+const applyBlocks = (repo, commands, script, git) => {
+	const recognizers = recognizersFor(repo, commands, git);
 	let output = "";
 	for (const block of splitBlocks(script)) {
 		const outcome = recognizeBlock(recognizers, block);
@@ -13266,11 +13270,12 @@ const failedAt = (outcome, output) => {
 		error: outcome.error
 	};
 };
+const UNRECOGNIZED_PREFIX = "unrecognized script block: ";
 const unrecognized = (block, output = "") => ({
 	ok: false,
 	status: 1,
 	output,
-	error: `unrecognized script block: ${block.split("\n")[0]}`
+	error: `${UNRECOGNIZED_PREFIX}${block.split("\n")[0]}`
 });
 //#endregion
 //#region src/testkit/TestRepo.ts
@@ -13322,10 +13327,17 @@ const LINES = [
 		repo.writeFile(dest, content);
 	}]
 ];
-const runLine = (repo, line) => {
-	const known = LINES.find(([pattern]) => pattern.test(line));
-	if (known === void 0) throw new Error(`testkit: cannot run \`${line}\` in memory — give the step an actor instead`);
-	known[1](repo, words(line));
+const knownLine = (line) => LINES.find(([pattern]) => pattern.test(line));
+const cannotRun = (error) => /* @__PURE__ */ new Error(`testkit: cannot run script in memory — give the step an actor instead\n${error}`);
+const runLines = (repo, script) => {
+	const lines = script.split("\n").map((line) => line.trim());
+	const known = lines.map(knownLine);
+	if (known.every(Boolean)) {
+		known.forEach((k, i) => k[1](repo, words(lines[i])));
+		return;
+	}
+	const applied = applyEmittedScript(repo, /* @__PURE__ */ new Map(), script, { git: false });
+	if (!applied.ok) throw cannotRun(applied.error ?? "");
 };
 const failed = (what, result) => /* @__PURE__ */ new Error(`${what} exited ${result.exitCode}\n${result.stderr}${result.stdout}`);
 const testRepo = (options) => {
@@ -13407,7 +13419,7 @@ const testRepo = (options) => {
 		show: (ref, path) => repo.fileAtRef(ref, path) ?? void 0,
 		runScript: (script) => {
 			const flow = applyFlowScript(repo, /* @__PURE__ */ new Map(), script);
-			if (flow === void 0) for (const line of script.split("\n")) runLine(repo, line.trim());
+			if (flow === void 0) runLines(repo, script);
 			else if (!flow.ok) throw new Error(`testkit: ${flow.error ?? ""}`);
 		},
 		gtd,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "27.6.0",
+  "version": "27.7.0",
   "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/cli/Cli.ts

@@ -241,7 +241,7 @@ const FLAGS: readonly FlagRow[] = [
     help: [
       "(gtd land, with --cost) tag that cost's model",
       "(gtd judge run, llm answerer) the claude model; omitted:",
-      "GTD_JUDGE_MODEL, then judge.json, then haiku",
+      "GTD_JUDGE_MODEL, then judge.json, then sonnet",
     ],
   },
   {
@@ -673,7 +673,7 @@ const COMMAND_ROWS: readonly CommandRow[] = [
       "--answers <path> or GTD_JUDGE_ANSWERS; questions the file",
       "does not cover are left out. --provider jev asks TypeSafe",
       "(TYPESAFE_API_KEY). --provider llm asks the `claude` CLI",
-      "on PATH (Claude Code only), model haiku unless --model.",
+      "on PATH (Claude Code only), model sonnet unless --model.",
       "No --provider: GTD_JUDGE_PROVIDER, then ~/.config/gtd/",
       "judge.json, else jev when TYPESAFE_API_KEY is set and no",
       "model is given, else llm; --model likewise falls back to",

package/src/testkit/EmittedScriptRecognizer.test.ts

@@ -630,6 +630,18 @@ describe("applyEmittedScript — Emit.ts's combinedScript (the whole stdout of a
     expect(repo.lastCommitMessage()).toBe("gtd(human): idle")
   })
 
+  it("fails an unrecognized optional block under git: false", () => {
+    const repo = new InMemRepo()
+    const result = applyEmittedScript(
+      repo,
+      NO_COMMANDS,
+      combinedScript("set -eu", "totally-unrecognized-command"),
+      { git: false },
+    )
+    expect(result.ok).toBe(false)
+    expect(result.error).toContain("totally-unrecognized-command")
+  })
+
   it("still fails loudly on an unrecognized block outside the presentation-only subshell", () => {
     const repo = new InMemRepo()
     const script = `${combinedScript("totally-unrecognized-required-command", "")}`
@@ -691,3 +703,32 @@ describe("applyEmittedScript — commitClean", () => {
     expect(snapshot(repo)).toEqual(before)
   })
 })
+
+describe("applyEmittedScript — git: false reaches through the presentation subshell", () => {
+  it("refuses a git builder wrapped in combinedScript and changes nothing", () => {
+    const repo = new InMemRepo()
+    repo.writeFile("a.txt", "1")
+    const before = snapshot(repo)
+    const result = applyEmittedScript(
+      repo,
+      NO_COMMANDS,
+      combinedScript("set -eu", commitAll("chore: sneaky")),
+      { git: false },
+    )
+    expect(result.ok).toBe(false)
+    expect(result.error).toMatch(/unrecognized script block/)
+    expect(snapshot(repo)).toEqual(before)
+  })
+
+  it("still applies a non-git write-lines optional half", () => {
+    const repo = new InMemRepo()
+    const result = applyEmittedScript(
+      repo,
+      NO_COMMANDS,
+      combinedScript("set -eu", "mkdir -p d\nprintf '%s\\n' 'x' > 'd/a.txt'"),
+      { git: false },
+    )
+    expect(result).toMatchObject({ ok: true })
+    expect(repo.readFile("d/a.txt")).toBe("x\n")
+  })
+})

package/src/testkit/EmittedScriptRecognizer.ts

@@ -563,7 +563,7 @@ const recognizeGtdUncheck = (repo: InMemRepo, block: string): BlockOutcome | und
 const recognizeDidNotRunComment = (block: string): BlockOutcome | undefined =>
   block === DID_NOT_RUN_COMMENT ? { kind: "noop" } : undefined
 
-/** `combinedScript`'s optional half. ALWAYS reports `noop` whatever the inner result, mirroring bash's `( … ) || <warning>`, where the subshell's exit status is swallowed and must never fail the outer script. */
+/** `combinedScript`'s optional half. Reports `noop` whatever the inner result, mirroring bash's `( … ) || <warning>`. Exception: under `git: false` any unrecognized inner block fails the outer script (git or not), so the in-memory twin knowingly diverges from `sh` rather than run git unseen. */
 const PRESENTATION_FAILURE_TEXT = `${extractQuotedTokens(PRESENTATION_FAILURE_WARNING)[0]!.replace(/\\n$/, "")}\n`
 const PRESENTATION_SUBSHELL_PREFIX = `${PRESENTATION_ONLY_COMMENT}\n(\n`
 const PRESENTATION_SUBSHELL_SUFFIX = `\n) || ${PRESENTATION_FAILURE_WARNING}`
@@ -572,6 +572,7 @@ const recognizePresentationSubshell = (
   repo: InMemRepo,
   commands: ReadonlyMap<string, ScriptedCommand>,
   block: string,
+  git: boolean,
 ): BlockOutcome | undefined => {
   if (
     !block.startsWith(PRESENTATION_SUBSHELL_PREFIX) ||
@@ -583,8 +584,11 @@ const recognizePresentationSubshell = (
     PRESENTATION_SUBSHELL_PREFIX.length,
     block.length - PRESENTATION_SUBSHELL_SUFFIX.length,
   )
-  const result = applyEmittedScript(repo, commands, inner)
+  const result = applyEmittedScript(repo, commands, inner, { git })
   if (result.ok) return { kind: "noop", output: result.output }
+  if (!git && result.error?.startsWith(UNRECOGNIZED_PREFIX)) {
+    return { kind: "failed", error: `${result.output}${result.error}` }
+  }
   return { kind: "noop", output: `${result.output}${PRESENTATION_FAILURE_TEXT}` }
 }
 
@@ -703,17 +707,18 @@ const recognizeWriteLines = (repo: InMemRepo, block: string): BlockOutcome | und
 const recognizersFor = (
   repo: InMemRepo,
   commands: ReadonlyMap<string, ScriptedCommand>,
+  git: boolean,
 ): ReadonlyArray<(block: string) => BlockOutcome | undefined> => [
   (block) => recognizeSetFlags(block),
   (block) => recognizeDidNotRunComment(block),
   (block) => recognizePrecondition(repo, block),
   (block) => recognizeFileExistsGuard(repo, block),
   (block) => recognizeBinaryGuard(commands, block),
-  (block) => recognizeGitBuilders(repo, block),
+  (block) => (git ? recognizeGitBuilders(repo, block) : undefined),
   (block) => recognizeDeferNotes(repo, block),
   (block) => recognizeWriteLines(repo, block),
   (block) => recognizeFailurePromptWrapper(repo, commands, block),
-  (block) => recognizePresentationSubshell(repo, commands, block),
+  (block) => recognizePresentationSubshell(repo, commands, block, git),
   (block) => recognizeModeContradictionSkipNotice(block),
   (block) => recognizeModeContradictionCheck(repo, commands, block),
   (block) => recognizeGtdCheck(repo, block),
@@ -746,6 +751,7 @@ export const applyEmittedScript = (
   repo: InMemRepo,
   commands: ReadonlyMap<string, ScriptedCommand>,
   script: string,
+  { git = true }: { readonly git?: boolean } = {},
 ): AppliedScriptResult => {
   const flow = applyFlowScript(repo, commands, script)
   if (flow !== undefined) {
@@ -753,15 +759,16 @@ export const applyEmittedScript = (
       ? { ok: true, status: 0, output: flow.output }
       : { ok: false, status: 1, output: flow.output, error: flow.error ?? "" }
   }
-  return script.startsWith("#!") ? unrecognized(script) : applyBlocks(repo, commands, script)
+  return script.startsWith("#!") ? unrecognized(script) : applyBlocks(repo, commands, script, git)
 }
 
 const applyBlocks = (
   repo: InMemRepo,
   commands: ReadonlyMap<string, ScriptedCommand>,
   script: string,
+  git: boolean,
 ): AppliedScriptResult => {
-  const recognizers = recognizersFor(repo, commands)
+  const recognizers = recognizersFor(repo, commands, git)
   let output = ""
   for (const block of splitBlocks(script)) {
     const outcome = recognizeBlock(recognizers, block)
@@ -786,9 +793,11 @@ const failedAt = (
   }
 }
 
+const UNRECOGNIZED_PREFIX = "unrecognized script block: "
+
 const unrecognized = (block: string, output = ""): AppliedScriptResult => ({
   ok: false,
   status: 1,
   output,
-  error: `unrecognized script block: ${block.split("\n")[0]}`,
+  error: `${UNRECOGNIZED_PREFIX}${block.split("\n")[0]}`,
 })

package/src/testkit/TestRepo.test.ts

@@ -1,4 +1,17 @@
 import { describe, expect, it } from "vitest"
+import {
+  commitAll,
+  combinedScript,
+  commitAsIs,
+  commitClean,
+  deleteRef,
+  discardPending,
+  hardResetTo,
+  keepTurn,
+  mixedResetTo,
+  softResetTo,
+  updateRef,
+} from "../emit/index.js"
 import { agent, human, moveScript, read, removeScript, run } from "../flows/index.js"
 import { runsItsScript, testRepo } from "./TestRepo.js"
 
@@ -93,7 +106,72 @@ describe("testRepo", () => {
 
   it("refuses to fake a script it cannot run", () => {
     const repo = testRepo({ workflow: { default: tiny } })
-    expect(() => repo.runScript("npm test\n")).toThrow(/cannot run `npm test` in memory/)
+    expect(() => repo.runScript("npm test\n")).toThrow(/cannot run script in memory[\s\S]*npm test/)
+  })
+
+  it("carries the recognizer's error when a git-free fallback fails", () => {
+    const repo = testRepo({ workflow: { default: tiny } })
+    expect(() => repo.runScript("printf 'x' > 'y'\n")).toThrow(
+      "testkit: cannot run script in memory — give the step an actor instead\nunrecognized script block: printf 'x' > 'y'",
+    )
+  })
+
+  it("names the block that failed, not an earlier line that ran", () => {
+    const repo = testRepo({ workflow: { default: tiny } })
+    let message = ""
+    try {
+      repo.runScript("mkdir -p d\nprintf '%s\\n' 'x' > 'd/a.txt'\n\nnpm test\n")
+    } catch (e) {
+      message = (e as Error).message
+    }
+    expect(message).toContain("unrecognized script block: npm test")
+    expect(message).not.toContain("printf")
+  })
+
+  it.each([
+    ["commitAll", commitAll("chore: sneaky")],
+    ["commitClean", commitClean("chore: sneaky")],
+    ["commitAsIs", commitAsIs("chore: sneaky")],
+    ["keepTurn", keepTurn("refs/x", "chore: sneaky")],
+    ["discardPending", discardPending()],
+    ["softResetTo", softResetTo("HEAD~1")],
+    ["mixedResetTo", mixedResetTo("HEAD~1")],
+    ["hardResetTo", hardResetTo("HEAD~1")],
+    ["updateRef", updateRef("refs/x", "HEAD")],
+    ["deleteRef", deleteRef("refs/x")],
+  ])("refuses a %s script instead of mutating git in memory", (_, script) => {
+    const repo = testRepo({ workflow: { default: tiny } })
+    repo.write("a.txt", "dirty\n")
+    const before = repo.subjects()
+    expect(() => repo.runScript(script)).toThrow(/unrecognized script block/)
+    expect(repo.subjects()).toEqual(before)
+  })
+
+  it.each([
+    ["commitAll", commitAll("chore: sneaky")],
+    ["commitClean", commitClean("chore: sneaky")],
+    ["commitAsIs", commitAsIs("chore: sneaky")],
+    ["keepTurn", keepTurn("refs/x", "chore: sneaky")],
+    ["discardPending", discardPending()],
+    ["softResetTo", softResetTo("HEAD~1")],
+    ["mixedResetTo", mixedResetTo("HEAD~1")],
+    ["hardResetTo", hardResetTo("HEAD~1")],
+    ["updateRef", updateRef("refs/x", "HEAD")],
+    ["deleteRef", deleteRef("refs/x")],
+  ])("refuses a wrapped %s script instead of mutating git in memory", (_, script) => {
+    const repo = testRepo({ workflow: { default: tiny } })
+    repo.write("a.txt", "dirty\n")
+    const before = repo.subjects()
+    expect(() => repo.runScript(combinedScript("set -eu", script))).toThrow(
+      /cannot run script in memory[\s\S]*unrecognized script block/,
+    )
+    expect(repo.subjects()).toEqual(before)
+  })
+
+  it("applies a write block `LINES` lacks through the git-free recognizers", () => {
+    const repo = testRepo({ workflow: { default: tiny } })
+    repo.runScript("mkdir -p d\nprintf '%s\\n' 'echo $(git rev-parse HEAD)' > 'd/a.txt'\n")
+    expect(repo.read("d/a.txt")).toBe("echo $(git rev-parse HEAD)\n")
   })
 
   it("reads a file as committed", () => {

package/src/testkit/TestRepo.ts

@@ -150,12 +150,23 @@ const LINES: ReadonlyArray<readonly [RegExp, (repo: InMemRepo, words: string[])
   ],
 ]
 
-const runLine = (repo: InMemRepo, line: string): void => {
-  const known = LINES.find(([pattern]) => pattern.test(line))
-  if (known === undefined) {
-    throw new Error(`testkit: cannot run \`${line}\` in memory — give the step an actor instead`)
+const knownLine = (line: string) => LINES.find(([pattern]) => pattern.test(line))
+
+const cannotRun = (error: string): Error =>
+  new Error(`testkit: cannot run script in memory — give the step an actor instead\n${error}`)
+
+// A script with a line `LINES` lacks goes to the contract-tested recognizers
+// whole, minus the git builders: they would apply a commit/reset/update-ref in
+// memory, so any git-mutating block is refused whatever its spelling.
+const runLines = (repo: InMemRepo, script: string): void => {
+  const lines = script.split("\n").map((line) => line.trim())
+  const known = lines.map(knownLine)
+  if (known.every(Boolean)) {
+    known.forEach((k, i) => k![1](repo, words(lines[i]!)))
+    return
   }
-  known[1](repo, words(line))
+  const applied = applyEmittedScript(repo, new Map(), script, { git: false })
+  if (!applied.ok) throw cannotRun(applied.error ?? "")
 }
 
 const failed = (what: string, result: CapturedCliResult): Error =>
@@ -251,7 +262,7 @@ export const testRepo = (options: TestRepoOptions): TestRepo => {
     show: (ref, path) => repo.fileAtRef(ref, path) ?? undefined,
     runScript: (script) => {
       const flow = applyFlowScript(repo, new Map(), script)
-      if (flow === undefined) for (const line of script.split("\n")) runLine(repo, line.trim())
+      if (flow === undefined) runLines(repo, script)
       else if (!flow.ok) throw new Error(`testkit: ${flow.error ?? ""}`)
     },
     gtd,

package/src/testkit/steps.ts

@@ -70,7 +70,15 @@ export class TestkitWorld extends QuickPickleWorld {
         for (const action of actions) await action(beat, repo)
       }
     }
-    for (const [step, verdict] of this.verdicts) actors[step] = () => verdict
+    for (const [step, verdict] of this.verdicts) {
+      // A verdict would overwrite the queued actions, silently skipping their checks.
+      if (this.actions.has(step)) {
+        throw new Error(
+          `step "${step}" has a judge verdict and queued actions; the actions would never run`,
+        )
+      }
+      actors[step] = () => verdict
+    }
     await this.repo().drive(actors)
   }
 }
@@ -120,6 +128,19 @@ Given(
   },
 )
 
+// A standing assertion like any queued action: it applies on every later visit
+// to the step until `from now on` clears the list.
+Given(
+  "step {string} is prompted with {string}",
+  (world: TestkitWorld, step: string, text: string) => {
+    world.act(step, (beat) => {
+      if (!beat.content.includes(text)) {
+        throw new Error(`step "${step}" was not prompted with "${text}":\n${beat.content}`)
+      }
+    })
+  },
+)
+
 Given("step {string} runs its script", (world: TestkitWorld, step: string) => {
   world.act(step, runsItsScript)
 })
@@ -207,6 +228,28 @@ Then("the commit subjects end with:", (world: TestkitWorld, list: string) => {
   assert.deepStrictEqual(world.repo().subjects().slice(-expected.length), expected)
 })
 
+const outputOf = async (world: TestkitWorld, list: string): Promise<string> => {
+  const result = await world.repo().gtd(...args(list))
+  assert.strictEqual(result.exitCode, 0, result.stderr)
+  return result.stdout
+}
+
+Then(
+  "the output of gtd {string} contains {string}",
+  async (world: TestkitWorld, list: string, text: string) => {
+    const out = await outputOf(world, list)
+    assert.ok(out.includes(text), out)
+  },
+)
+
+Then(
+  "the output of gtd {string} does not contain {string}",
+  async (world: TestkitWorld, list: string, text: string) => {
+    const out = await outputOf(world, list)
+    assert.ok(!out.includes(text), out)
+  },
+)
+
 Then("{string} contains {string}", (world: TestkitWorld, path: string, text: string) => {
   assert.ok(world.repo().read(path)?.includes(text), `${path}: ${world.repo().read(path)}`)
 })

package/src/testkit/testkit.feature

@@ -1,3 +1,4 @@
+@inmem
 Feature: testkit drives any workflow against the real engine
 
   A workflow the scenario writes itself, never a shipped one: scripted actors
@@ -47,6 +48,8 @@ Feature: testkit drives any workflow against the real engine
       gtd(judge): ready → ship
       """
     And "PLAN.md" contains "add two numbers"
+    And the output of gtd "next" contains "ship"
+    And the output of gtd "next" does not contain "rework"
 
   Scenario: a red check sends the process to repair, and an unscripted step is where it rests
     Given step "plan" writes "PLAN.md" with:
@@ -63,6 +66,38 @@ Feature: testkit drives any workflow against the real engine
     And the resting step's content contains "Make the suite pass."
     And the last commit subject is "gtd(check): check → repair"
 
+  Scenario: a step's beat content is asserted as a queued actor
+    Given step "plan" is prompted with "Write PLAN.md."
+    And step "plan" writes "PLAN.md" with:
+      """
+      add two numbers
+      """
+    And step "check" changes nothing
+    And judge step "ready" answers:
+      """
+      [{ "id": "ready", "answer": true, "p": 0.9 }]
+      """
+    When gtd starts workflow "tiny"
+    And the process is driven
+    Then the process rests at "ship"
+    And "PLAN.md" contains "add two numbers"
+
+  Scenario: a judge step with queued actions refuses the drive
+    Given step "plan" changes nothing
+    And step "check" changes nothing
+    And step "ready" is prompted with "never seen"
+    And judge step "ready" answers:
+      """
+      [{ "id": "ready", "answer": true, "p": 0.9 }]
+      """
+    When gtd starts workflow "tiny"
+    Then driving the process is refused with "queued actions"
+
+  Scenario: a beat that lacks the expected text refuses the drive
+    Given step "plan" is prompted with "Write a poem"
+    When gtd starts workflow "tiny"
+    Then driving the process is refused with 'was not prompted with "Write a poem"'
+
   Scenario: a start the workflow refuses is reported with its message
     Then starting workflow "picky" with "--var mode=bad" is refused with "picky refuses every start"