@pmelab/gtd 27.1.0 → 27.2.0

package/dist/workflows.mjs

@@ -17805,12 +17805,22 @@ const escalationSteps = {
 	stop: escalate,
 	exhausted: escalationExhausted
 };
+const guarded = (turn, guard) => async (...a) => {
+	await turn(...a);
+	guard?.();
+};
+const guardedSteps = (guard) => ({
+	limit: escalationSteps.limit,
+	describe: guarded(escalationSteps.describe, guard),
+	stop: guarded(escalationSteps.stop, guard),
+	exhausted: guarded(escalationSteps.exhausted, guard)
+});
 /**
 * Hand a red suite that repeated attempts could not fix to a person: an
 * agent writes `.gtd/ESCALATION.md`, a human narrows it. From the third round
 * on, the human is told the budget is spent instead.
 */
-const escalation = (count) => escalation$1(count, escalationSteps);
+const escalation = (count, guard) => escalation$1(count, guardedSteps(guard));
 /** "Is this red round the same failure as the last one?" — asked of two reports, or of nothing when one is empty. */
 const retryQuestion = (comparable) => comparable ? {
 	id: "verdict",
@@ -17846,21 +17856,25 @@ const runSuite = (options) => check("health.check", env.testCommand ?? "", {
 * first once `FIX_CAP` fixes are spent, or a judge calls the failure
 * identical to the previous round's.
 */
-const healthy = (fix, options = {}) => healthy$1(fix, {
+const healthy = (fix, options = {}) => healthy$1(guarded(fix, options.guard), {
 	check: () => runSuite(options),
 	report: FEEDBACK,
 	fixCap: 3,
 	fixesSoFar: options.fixesSoFar ?? 0,
 	sameFailure,
 	escalations: options.escalations ?? { rounds: 0 },
-	escalation: escalationSteps
+	escalation: guardedSteps(options.guard)
 });
-/** Hold the process at `<name>.blocked` until the suite is green. */
-const gate = (name, message) => gate$1(name, () => baseline("check"), () => human("blocked", {
+/**
+* Hold the process at `<name>.blocked` until the suite is green. `guard` runs
+* after each `blocked` landing only — never after a check, whose refusal would
+* re-run the same script forever.
+*/
+const gate = (name, message, guard) => gate$1(name, () => baseline("check"), guarded(() => human("blocked", {
 	message,
 	label: "Baseline is red",
 	file: FEEDBACK
-}));
+}), guard));
 //#endregion
 //#region node_modules/effect/dist/esm/Function.js
 /**
@@ -37221,6 +37235,27 @@ const shipped = (flow, doors, base) => defineWorkflow(standardSchemaV1(ShippedOp
 	doors,
 	base
 }));
+const FlagOptions = Struct({
+	...ShippedOptions.fields,
+	flagRegistry: setting
+});
+const flagShipped = (flow) => defineWorkflow(standardSchemaV1(FlagOptions, {
+	onExcessProperty: "error",
+	errors: "all"
+}), (options) => {
+	const flagDefaults = {
+		...defaults,
+		flag: "",
+		flagRegistry: "src/flags/index.ts"
+	};
+	return {
+		flow,
+		defaults: over(flagDefaults, options),
+		envDefaults: over(envDefaults, options),
+		doors: {},
+		base: void 0
+	};
+});
 //#endregion
 //#region src/workflows/shared/tail.ts
 /** The reviewer's own `.gtd/REVIEW.md`, kept beside the human's notes so `fix` can tell them apart. */
@@ -37230,13 +37265,13 @@ const REVIEW_ORIG = ".gtd/REVIEW.orig.md";
 * finding to `.gtd/QUALITY.md`. Resolves `"findings"` when that file
 * has any.
 */
-const qualityLap = () => qualityLap$1(lensesOf(vars.qualityReviews ?? ""), reviewQuality, QUALITY);
+const qualityLap = (guard) => qualityLap$1(lensesOf(vars.qualityReviews ?? ""), guarded(reviewQuality, guard), QUALITY);
 /** Resolves `true` once `.gtd/QUALITY.md` is resolved, `false` when the fix cap escalated instead. */
-const fixQualityFindings = (escalations) => fixFindings({
-	fix: fixQuality,
+const fixQualityFindings = (escalations, guard) => fixFindings({
+	fix: guarded(fixQuality, guard),
 	findings: QUALITY,
 	cap: 3,
-	escalate: () => escalation(escalations)
+	escalate: () => escalation(escalations, guard)
 });
 /** `.gtd/REVIEW.md` removed at the end of a round at commit `round`. */
 const closeReview = (round) => run("review.closing", removeScript([REVIEW, REVIEW_ORIG]), {
@@ -37252,19 +37287,26 @@ const refusePendingHandOff = () => {
 * `finish` — the human review, as the calling workflow runs it. `green`: the
 * caller just left the full suite green (the package loop), so no run opens it.
 */
-const tail = (fixFirst, finish, green = false) => scope("build", async () => {
+const tail = (fixFirst, finish, green = false, guard) => scope("build", async () => {
 	const escalations = { rounds: 0 };
 	const fix = fixCheck;
 	const repair = async () => {
-		await fix();
+		await guarded(fix, guard)();
 		await healthy(fix, {
 			fixesSoFar: 1,
-			escalations
+			escalations,
+			guard
 		});
 	};
 	if (fixFirst) await repair();
-	else if (!green) await healthy(fix, { escalations });
-	if (await qualityLap() === "findings") if (await fixQualityFindings(escalations)) await healthy(fix, { escalations });
+	else if (!green) await healthy(fix, {
+		escalations,
+		guard
+	});
+	if (await qualityLap(guard) === "findings") if (await fixQualityFindings(escalations, guard)) await healthy(fix, {
+		escalations,
+		guard
+	});
 	else await repair();
 	return finish(escalations);
 });
@@ -37273,11 +37315,14 @@ const tail = (fixFirst, finish, green = false) => scope("build", async () => {
 * `.gtd/REVIEW.md`; a note leaves it, with the reviewer's own version as
 * `REVIEW_ORIG`, for the next `fix` to read — never a re-plan.
 */
-const handOffReview = (base, escalations) => reviewToHandOff(base, {
+const handOffReview = (base, escalations, guard) => reviewToHandOff(base, {
 	file: REVIEW,
-	reviewing,
-	fixRisks,
-	keepGreen: () => healthy(fixCheck, { escalations }),
+	reviewing: guarded(reviewing, guard),
+	fixRisks: guarded(fixRisks, guard),
+	keepGreen: () => healthy(fixCheck, {
+		escalations,
+		guard
+	}),
 	awaitReview: (b) => awaitReview(b, handOffAwaitReviewMessage(b)),
 	reviewMissing,
 	close: closeReview,
@@ -37287,7 +37332,7 @@ const handOffReview = (base, escalations) => reviewToHandOff(base, {
 	deleted: "gtd land: review-doc: .gtd/REVIEW.md was deleted — restore it, or leave a note to hand to fix."
 });
 /** The tail the review and fix workflows run: ends at the hand-off review since `base`. */
-const handOffTail = (fixFirst, base) => tail(fixFirst, (escalations) => handOffReview(base, escalations));
+const handOffTail = (fixFirst, base, guard) => tail(fixFirst, (escalations) => handOffReview(base, escalations, guard), false, guard);
 //#endregion
 //#region src/workflows/feature/steps.ts
 /** Turn the sketch since `base` into `.gtd/REQUIREMENTS.md`. */
@@ -37789,6 +37834,160 @@ const fixFlow = async () => {
 };
 const fix = shipped(fixFlow, { fix: {} });
 //#endregion
+//#region src/workflows/shared/registry.ts
+const FILL = "
";
+const commentLength = (rest) => {
+	const end = rest.startsWith("//") ? rest.indexOf("\n") : rest.indexOf("*/") + 2;
+	return end <= 0 ? rest.length : end;
+};
+const stringEnd = (text, i, quote) => {
+	let j = i + 1;
+	while (j < text.length && text[j] !== quote) j += text[j] === "\\" ? 2 : 1;
+	return Math.min(j, text.length);
+};
+const mask = (text) => {
+	let out = "";
+	let i = 0;
+	while (i < text.length) {
+		const c = text[i];
+		const rest = text.slice(i);
+		if (rest.startsWith("//") || rest.startsWith("/*")) {
+			const len = commentLength(rest);
+			out += FILL.repeat(len);
+			i += len;
+		} else if (c === "\"" || c === "'" || c === "`") {
+			const j = stringEnd(text, i, c);
+			out += c + FILL.repeat(j - i - 1) + (j < text.length ? c : "");
+			i = j + 1;
+		} else {
+			out += c;
+			i += 1;
+		}
+	}
+	return out;
+};
+const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const entrySpan = (text, name) => {
+	const quoted = escapeRegExp(name);
+	const re = new RegExp(`\\bname\\s*:\\s*(["'\`])${quoted}\\1`, "g");
+	const masked = mask(text);
+	for (const hit of text.matchAll(re)) {
+		if (masked[hit.index] === FILL) continue;
+		const start = masked.lastIndexOf("{", hit.index);
+		const close = masked.indexOf("}", hit.index);
+		return start < 0 || close < 0 ? void 0 : {
+			start,
+			end: close + 1
+		};
+	}
+};
+const DEFAULT_ON = /\bdefaultOn\s*:\s*(true|false)\s*,?/;
+const defaultOnHit = (body) => DEFAULT_ON.exec(mask(body));
+const defaultOnValue = (body) => defaultOnHit(body)?.[1];
+const KIND = /\bkind\s*:\s*["'`]/;
+const registryEntry = (text, name) => {
+	const span = entrySpan(text, name);
+	if (span === void 0) return void 0;
+	const body = text.slice(span.start, span.end);
+	const hit = KIND.exec(mask(body));
+	return {
+		kind: (hit === null ? null : /^(\w+)["'`]/.exec(body.slice(hit.index + hit[0].length)))?.[1] ?? "",
+		defaultOn: defaultOnValue(body) === "true"
+	};
+};
+const canonical = (body) => {
+	const hit = defaultOnHit(body);
+	const kept = hit === null ? body : body.slice(0, hit.index) + body.slice(hit.index + hit[0].length);
+	const masked = mask(kept);
+	return kept.split("").filter((c, i) => masked[i] === FILL || !(/\s/.test(c) || c === "," && /^\s*}/.test(masked.slice(i + 1)))).join("");
+};
+/**
+* [] when `after` differs from `before` only by the named entry's `defaultOn`
+* going absent/false → true (whitespace and trailing commas inside that entry
+* ignored, so oxfmt re-wrapping it passes); else one line per fault.
+*/
+const flipProblems = (before, after, name) => {
+	const was = entrySpan(before, name);
+	const now = entrySpan(after, name);
+	if (was === void 0) return [`no entry "${name}" before the turn`];
+	if (now === void 0) return [`entry "${name}" is gone`];
+	const faults = [];
+	if (before.slice(0, was.start) !== after.slice(0, now.start)) faults.push("text before the entry changed");
+	if (before.slice(was.end) !== after.slice(now.end)) faults.push("text after the entry changed");
+	const oldBody = before.slice(was.start, was.end);
+	const newBody = after.slice(now.start, now.end);
+	if (canonical(oldBody) !== canonical(newBody)) faults.push(`entry "${name}" changed beyond defaultOn`);
+	if (defaultOnValue(newBody) !== "true") faults.push(`"${name}" is not set to defaultOn: true`);
+	return faults;
+};
+/** `path:line` for every `GTD_FLAG_<NAME>` in shipped sources; re-states scripts/lint-flags.ts' rule by hand. */
+const flagReferences = (files, name) => {
+	const pattern = new RegExp(`\\bGTD_FLAG_${escapeRegExp(name.toUpperCase())}\\b`);
+	return files.filter(({ path }) => !/\.(test|fixture|stories)\.tsx?$/.test(path)).flatMap(({ path, text }) => text.split("\n").flatMap((line, i) => pattern.test(line) ? [`${path}:${i + 1}`] : []));
+};
+const requireFlag = (workflow, registryPath, name, defaultOn) => {
+	if (name === "") return refuse(`gtd: ${workflow} needs --var flag=<name>`);
+	const entry = registryEntry(read(registryPath) ?? "", name);
+	if (entry === void 0) return refuse(`gtd: ${workflow}: no flag "${name}" in ${registryPath}`);
+	if (entry.kind !== "release") return refuse(`gtd: ${workflow}: flag "${name}" is ${entry.kind}, not release`);
+	if (entry.defaultOn !== defaultOn) return refuse(defaultOn ? `gtd: ${workflow}: flag "${name}" is not default-on — roll it out first` : `gtd: ${workflow}: flag "${name}" is already default-on`);
+};
+//#endregion
+//#region src/workflows/rollout/rollout.ts
+const flippingPrompt = (name, registry) => `Roll out the release flag "${name}": in ${registry}, set \`defaultOn: true\` on its entry. Change nothing else — no other entry, no other field, no other file, no comments.`;
+const suiteBlockedMessage = () => "The suite is red after the rollout. Fix it by hand — a rollout may only touch the flag's registry entry — then land.";
+const rolloutFlow = async () => {
+	const registry = vars.flagRegistry ?? "";
+	const name = vars.flag ?? "";
+	requireFlag("rollout", registry, name, false);
+	const base = head$1();
+	const before = read(registry) ?? "";
+	const guard = () => {
+		const strays = changesSince(base).paths.filter((path) => path !== registry && path !== ".gtd/FEEDBACK.md");
+		if (strays.length > 0) refuse(`gtd land: rollout-only: ${strays.join(", ")} changed — rollout may only set defaultOn: true on "${name}" in ${registry}`);
+		const problems = flipProblems(before, read(registry) ?? "", name);
+		if (problems.length > 0) refuse(`gtd land: rollout-only: other edits in ${registry}: ${problems.join("; ")}`);
+	};
+	await scope("rollout", async () => {
+		await agent("flipping", flippingPrompt(name, registry), {
+			label: `Rolling out ${name}`,
+			model: coder()
+		});
+		guard();
+		await gate("suite", suiteBlockedMessage(), guard);
+	});
+};
+const rollout = flagShipped(rolloutFlow);
+//#endregion
+//#region src/workflows/cleanup/cleanup.ts
+const removingPrompt = (name, registry) => `Clean up the release flag "${name}", which is default-on: delete its entry in ${registry}, and remove every \`GTD_FLAG_${name.toUpperCase()}\` check from the shipped sources. Keep the flag-on path; delete code only the off path reached, including tests that pin the off path.`;
+const cleanupFlow = async () => {
+	const registry = vars.flagRegistry ?? "";
+	const name = vars.flag ?? "";
+	refusePendingHandOff();
+	requireFlag("cleanup", registry, name, true);
+	let scanned = false;
+	const guard = () => {
+		const turn = scanned ? changes() : void 0;
+		if ((turn === void 0 || turn.some((c) => c.path === registry)) && registryEntry(read(registry) ?? "", name) !== void 0) refuse(`gtd land: cleanup: ${registry} still declares flag "${name}"`);
+		const hits = flagReferences((turn === void 0 ? [...glob("src/**/*.ts"), ...glob("src/**/*.tsx")] : turn.filter((c) => c.status !== "deleted").map((c) => c.path).filter((path) => path.startsWith("src/") && /\.tsx?$/.test(path))).map((path) => ({
+			path,
+			text: read(path) ?? ""
+		})), name);
+		if (hits.length > 0) refuse(`gtd land: cleanup: ${hits.join(", ")} still names GTD_FLAG_${name.toUpperCase()}`);
+	};
+	await scope("cleanup", async () => {
+		await agent("removing", removingPrompt(name, registry), {
+			label: `Removing ${name}`,
+			model: coder()
+		});
+		guard();
+		scanned = true;
+	});
+	await handOffTail(false, start(), guard);
+};
+const cleanup = flagShipped(cleanupFlow);
+//#endregion
 //#region src/workflows/index.ts
 var workflows_default = feature;
 /**
@@ -37797,4 +37996,4 @@ var workflows_default = feature;
 */
 const doors = {};
 //#endregion
-export { ARCHITECTURE, ESCALATION, FEEDBACK, FIX_CAP, QUALITY, REQUIREMENTS, REVIEW, REVIEW_ORIG, ShippedOptions, access, afterTail, agentWithSkills, answerProductQuestions, answerReviewQuestions, answerTechnicalQuestions, architecture, author, awaitReview, base, baseline, build, buildTail, builtInLenses, closeReview, coder, collecting, declaredTests, decompose, workflows_default as default, defaults, deferNotes, describeEscalation, design, doors, envDefaults, escalate, escalation, escalationExhausted, feature, fix, fixCheck, fixFlow, fixNits, fixQuality, fixQualityFindings, fixReviewNotes, fixRisks, fixSuite, gate, handOffReview, handOffTail, healthy, lensesOf, nextPackage, ordinaryStart, packageItem, packages, planAndBuild, planner, qualityLap, reUnwind, requireDeclaredTests, retryQuestion, review, reviewFlow, reviewMissing, reviewQuality, reviewing, skills, steering, summary, tail, threads, triage, unwind };
+export { ARCHITECTURE, ESCALATION, FEEDBACK, FIX_CAP, FlagOptions, QUALITY, REQUIREMENTS, REVIEW, REVIEW_ORIG, ShippedOptions, access, afterTail, agentWithSkills, answerProductQuestions, answerReviewQuestions, answerTechnicalQuestions, architecture, author, awaitReview, base, baseline, build, buildTail, builtInLenses, cleanup, cleanupFlow, closeReview, coder, collecting, declaredTests, decompose, workflows_default as default, defaults, deferNotes, describeEscalation, design, doors, envDefaults, escalate, escalation, escalationExhausted, feature, fix, fixCheck, fixFlow, fixNits, fixQuality, fixQualityFindings, fixReviewNotes, fixRisks, fixSuite, gate, guarded, handOffReview, handOffTail, healthy, lensesOf, nextPackage, ordinaryStart, packageItem, packages, planAndBuild, planner, qualityLap, reUnwind, requireDeclaredTests, retryQuestion, review, reviewFlow, reviewMissing, reviewQuality, reviewing, rollout, rolloutFlow, skills, steering, summary, tail, threads, triage, unwind };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "27.1.0",
+  "version": "27.2.0",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {
@@ -52,6 +52,16 @@
       "source": "./src/workflows/index.ts",
       "default": "./dist/workflows.mjs"
     },
+    "./workflows/rollout": {
+      "types": "./src/workflows/rollout/index.ts",
+      "source": "./src/workflows/rollout/index.ts",
+      "default": "./dist/workflows/rollout.mjs"
+    },
+    "./workflows/cleanup": {
+      "types": "./src/workflows/cleanup/index.ts",
+      "source": "./src/workflows/cleanup/index.ts",
+      "default": "./dist/workflows/cleanup.mjs"
+    },
     "./testkit": {
       "types": "./src/testkit/index.ts",
       "source": "./src/testkit/index.ts",

package/src/flags/index.test.ts

@@ -55,6 +55,34 @@ describe("resolveFlags", () => {
   })
 })
 
+describe("resolveFlags defaultOn", () => {
+  const on = [
+    { name: "beta", owner: "pmelab", expiry: "2099-01-01", kind: "release", defaultOn: true },
+  ] as const satisfies readonly FlagDeclaration[]
+
+  it.each([undefined, ""])("reads unset or empty (%j) as on", (value) => {
+    expect(resolveFlags({ GTD_FLAG_BETA: value }, on).beta).toBe(true)
+  })
+
+  it.each(["0", "false", "FALSE"])("%s still forces a default-on flag off", (value) => {
+    expect(resolveFlags({ GTD_FLAG_BETA: value }, on).beta).toBe(false)
+  })
+
+  it.each(["1", "true"])("%s forces a default-on flag on", (value) => {
+    expect(resolveFlags({ GTD_FLAG_BETA: value }, on).beta).toBe(true)
+  })
+
+  it("still throws for a garbled value", () => {
+    expect(() => resolveFlags({ GTD_FLAG_BETA: "ture" }, on)).toThrow(
+      /^GTD_FLAG_BETA must be 1, 0, true or false$/,
+    )
+  })
+
+  it("reads an entry without defaultOn as off when unset", () => {
+    expect(resolveFlags({}, [...on, ...registry]).alpha).toBe(false)
+  })
+})
+
 describe("FLAGS", () => {
   it("declares settable, unique variable names", () => {
     // Vacuous while FLAGS is empty; guards the first declared flag.

package/src/flags/index.ts

@@ -9,6 +9,8 @@ export interface FlagDeclaration {
   /** ISO `YYYY-MM-DD`; never enforced at runtime. */
   readonly expiry: string
   readonly kind: FlagKind
+  /** Unset or empty resolves on; `0`/`false` is still the kill switch. */
+  readonly defaultOn?: boolean
 }
 
 export const FLAGS = [] as const satisfies readonly FlagDeclaration[]
@@ -18,17 +20,20 @@ export type Flags<R extends readonly FlagDeclaration[] = typeof FLAGS> = {
   readonly [N in R[number]["name"]]: boolean
 }
 
-const BOOL: Record<string, boolean> = { "": false, "0": false, false: false, "1": true, true: true }
+const BOOL: Record<string, boolean> = { "0": false, false: false, "1": true, true: true }
 
 export const resolveFlags = <const R extends readonly FlagDeclaration[] = typeof FLAGS>(
   env: Readonly<Record<string, string | undefined>>,
   registry: R = FLAGS as unknown as R,
 ): Flags<R> => {
   const out: Record<string, boolean> = {}
-  for (const { name } of registry) {
+  for (const { name, defaultOn } of registry) {
     const variable = `GTD_FLAG_${name.toUpperCase()}`
-    const raw = env[variable] ?? ""
-    const key = raw.toLowerCase()
+    const key = (env[variable] ?? "").toLowerCase()
+    if (key === "") {
+      out[name] = defaultOn ?? false
+      continue
+    }
     if (!Object.hasOwn(BOOL, key)) {
       throw new Error(`${variable} must be 1, 0, true or false`)
     }

package/src/testkit/steps.ts

@@ -98,6 +98,11 @@ Given("step {string} changes nothing", (world: TestkitWorld, step: string) => {
   world.act(step, () => undefined)
 })
 
+// Unlike `changes nothing`, this drops every action already queued for the step.
+Given("step {string} from now on changes nothing", (world: TestkitWorld, step: string) => {
+  world.actions.set(step, [() => undefined])
+})
+
 Given(
   "step {string} writes {string} with:",
   (world: TestkitWorld, step: string, path: string, content: string) => {
@@ -150,6 +155,22 @@ Then(
   },
 )
 
+Then(
+  "starting workflow {string} with {string} is refused with {string}",
+  async (world: TestkitWorld, workflow: string, list: string, message: string) => {
+    await assert.rejects(world.repo().start(workflow, ...args(list)), (error: Error) =>
+      error.message.includes(message),
+    )
+  },
+)
+
+Then(
+  "driving the process is refused with {string}",
+  async (world: TestkitWorld, message: string) => {
+    await assert.rejects(world.drive(), (error: Error) => error.message.includes(message))
+  },
+)
+
 Then("the process rests at {string}", async (world: TestkitWorld, step: string) => {
   assert.strictEqual((await world.repo().next()).state, step)
 })
@@ -172,6 +193,11 @@ Then("{string} contains {string}", (world: TestkitWorld, path: string, text: str
   assert.ok(world.repo().read(path)?.includes(text), `${path}: ${world.repo().read(path)}`)
 })
 
+Then("{string} does not contain {string}", (world: TestkitWorld, path: string, text: string) => {
+  const content = world.repo().read(path)
+  assert.ok(content !== undefined && !content.includes(text), `${path}: ${content}`)
+})
+
 Then("{string} does not exist", (world: TestkitWorld, path: string) => {
   assert.strictEqual(world.repo().read(path), undefined)
 })

package/src/testkit/testkit.feature

@@ -6,7 +6,7 @@ Feature: testkit drives any workflow against the real engine
   Background:
     Given a gtd config with:
       """
-      import { agent, human, judge, read, run } from "@pmelab/gtd/flows"
+      import { agent, human, judge, read, refuse, run } from "@pmelab/gtd/flows"
 
       export const tiny = async () => {
         await agent("plan", "Write PLAN.md.")
@@ -19,6 +19,10 @@ Feature: testkit drives any workflow against the real engine
         await human(answers.ready?.answer === "yes" ? "ship" : "rework")
       }
 
+      export const picky = async () => {
+        refuse("gtd: picky refuses every start")
+      }
+
       export default tiny
       """
 
@@ -59,6 +63,9 @@ 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 start the workflow refuses is reported with its message
+    Then starting workflow "picky" with "--var mode=bad" is refused with "picky refuses every start"
+
   # Fails if run: proves the `workflows` project honours @skip.
   @skip
   Scenario: a scenario tagged @skip never runs