@bensandee/tooling 0.95.0 → 0.96.0

package/dist/bin.mjs

@@ -175,7 +175,7 @@ function loadEnvFileForBin(rawArgs, bin, io = processIo) {
 //#region src/env-file-preload.ts
 const envFileLoad = loadEnvFileForBin(process.argv.slice(2), {
 	name: "bst",
-	version: "0.95.0"
+	version: "0.96.0"
 });
 //#endregion
 //#region ../cli-kit/src/logger.ts
@@ -1747,7 +1747,8 @@ const LintSweepConfigSchema = z.strictObject({
 const AgentEgressConfigSchema = z.strictObject({ browseHosts: z.array(z.string().min(1)).optional().meta({ description: "Host patterns this repo's agent containers may fetch from, on top of the hosts every run needs: an exact host (`fastdl.mongodb.org`) or a wildcard over its leftmost label (`*.example.com`). No ports. These join the browse lane, which serves GET and HEAD only." }) });
 const AgentConfigSchema = z.strictObject({
 	enabled: z.boolean().optional().meta({ description: "The repo's explicit consent to the agent (default false). Only `true`, read from the repo's **default branch**, lets the agent work the repo: claim units, run sweeps, recover orphans, merge, act on a chat proposal or start a new spec. A missing key, `false`, a missing `.tooling.json` or a read that fails all mean not enabled, and the answer is re-read within about a minute. Every other `agent.*` key below has no effect without this one; `repo:sync` warns when the block sets one of them and this key is not `true`. Where this is `true`, `repo:sync` also installs `@bensandee/agent-cli`. `pnpm exec bst setup:agent` sets it to true and runs the sync. Provisioning the agent's labels is not consent, and is never gated by this key." }),
-	autonomy: z.boolean().optional().meta({ description: "Opt into interior autonomy (default false). When a phase's latest rationale reports readiness \"ready\" with an empty openQuestions[] and the review phase is clean, the agent applies the existing plan -> implement -> review -> park-at-mergeable advance itself instead of parking for a human. Never applies to the design/spec gate or the final merge from the mergeable terminal -- those always wait on a human. Also arms the trunk-red detector: when this repo's default branch combined status settles red, the agent files a tracking issue naming the failing checks and labels it agent/spec, starting the fix through the ordinary spec/plan/implement/review pipeline. It also closes that issue, with a comment, if the default branch recovers on its own before a human acts on it. Also arms the world-changed retrigger sweep: a pull request labelled agent-flags/autopilot that is parked at a -stuck or -failed terminal is re-queued when the fact its park recorded stops being true (the default branch went green, or moved past a conflicted base)." }),
+	autonomy: z.boolean().optional().meta({ description: "Retired and ignored -- it armed neither the advance rung nor the sweeps it once did. Advance is now the unit's own `agent-flags/advance` or `agent-flags/autopilot` label, and the trunk-red detector and world-changed retrigger sweep read `agent.trunkRed`. The key is still accepted so an existing config keeps syncing; the agent warns once per launch for a repo that still sets it." }),
+	trunkRed: z.boolean().optional().meta({ description: "Whether this repo's trunk-red detector and world-changed retrigger sweep run (default: on). The detector files a tracking issue when the default branch's combined status settles red and labels it agent/spec, and closes that issue with a comment if the branch recovers on its own before a human acts on it. The retrigger sweep re-queues a pull request labelled agent-flags/autopilot parked at a -stuck or -failed terminal when the fact its park recorded stops being true (the default branch went green, or moved past a conflicted base). A missing key means on; false disarms both." }),
 	preRunRebase: z.boolean().optional().meta({ description: "Merge the current default branch into the work branch before the container starts (default true) -- for an implement (execute) run, and for a spec or plan rerun on an existing branch. A clean merge or an already-up-to-date branch runs the container as is; a conflicting merge is aborted, recorded on the run's status comment, and the run proceeds on the un-synced branch -- a conflict, timeout or failed merge never fails the run, for any phase. Only the execute phase keeps the two-strike rule: two consecutive conflicting attempts hand the unit to agent/repair before any container runs, while a docs run just tries again on its next slice. Set false to skip the attempt entirely for this repo, in every phase: no fetch, no merge, no abort, and the branch is worked exactly as cloned." }),
 	backlog: z.boolean().optional().meta({ description: "Whether the agent may self-trigger backlog runs consuming this repo's .agent/findings/ ledger (default: on wherever the ledger exists, which only happens in a repo whose own review loop wrote it). A backlog run opens a pull request that fixes or refutes the pending findings; false disarms it, leaving the ledger to accumulate for a human. A run starts only once at least three findings are pending or one is older than seven days." }),
 	lintSweep: LintSweepConfigSchema.optional().meta({ description: "The lint-warning sweep: a periodic agent job that measures this repo's oxlint warnings on its default branch in a container and, past minWarnings, opens a pull request carrying a generated plan for an agent/implement run to work off." }),
@@ -1829,7 +1830,7 @@ const ToolingConfigSchema = z.strictObject({
 	]).optional().meta({ description: "What compiles the project. Detected from the package.json build script, then config-file presence. Setting this key pins its value, even one that equals detection, and repo:sync keeps it until the key is deleted." }),
 	checks: ChecksConfigSchema.optional().meta({ description: "Check-pipeline overrides: extra steps to add, and steps to skip (unioned with CI defaults)." }),
 	lint: LintConfigSchema.optional().meta({ description: "bst lint:types (the type-aware oxlint gate) overrides. See lint.strictTypeAware." }),
-	agent: AgentConfigSchema.optional().meta({ description: "agent:start behaviour overrides. Opt-in: see agent.autonomy for the interior-autonomy gate." }),
+	agent: AgentConfigSchema.optional().meta({ description: "agent:start behaviour overrides. Opt-in: agent.enabled is the consent gate -- every other key in the block does nothing without it." }),
 	branchPrune: BranchPruneConfigSchema.optional().meta({ description: "bst branch:prune overrides: mergedDays/backupDays windows, and extra never-touch exclusions layered on top of the hard-coded list." }),
 	issues: IssuesConfigSchema.optional().meta({ description: "Repo-level issue policy -- currently just the default reviewer(s) `bst issue:create` assigns. The natural home for any future issue-policy key." })
 });
@@ -2613,6 +2614,13 @@ function resolveComposeFileSet(readFile, projectRoot, composeFiles) {
 //#endregion
 //#region ../forgejo/src/fetcher.ts
 const LONG_FETCH_TIMEOUT_MS = 6e5;
+function morePagesFollow(res, pageLength, received, pageSize) {
+	if (pageLength === 0) return false;
+	const raw = res.headers.get("x-total-count")?.trim() ?? "";
+	const total = raw === "" ? NaN : Number(raw);
+	if (!Number.isSafeInteger(total) || total < 0) return pageLength >= pageSize;
+	return received < total;
+}
 //#endregion
 //#region ../forgejo/src/fetch-retry.ts
 const DEFAULT_RETRY_POLICY = {
@@ -5524,7 +5532,7 @@ function buildManagedDevDeps(ctx) {
 	const devDeps = { ...rootDevDeps(ctx.config) };
 	if (!isMonorepo) Object.assign(devDeps, perPackageDevDeps(ctx.config));
 	if (ctx.config.stack !== "none") devDeps["@bensandee/config"] = isWorkspacePackage(ctx, "@bensandee/config") ? "workspace:*" : "0.15.0";
-	if (!isWorkspacePackage(ctx, "@bensandee/tooling")) devDeps["@bensandee/tooling"] = "0.95.0";
+	if (!isWorkspacePackage(ctx, "@bensandee/tooling")) devDeps["@bensandee/tooling"] = "0.96.0";
 	if (ctx.config.useEslintPlugin && ctx.config.stack !== "none") devDeps["@bensandee/eslint-plugin"] = isWorkspacePackage(ctx, "@bensandee/eslint-plugin") ? "workspace:*" : "0.17.0";
 	if (wantsAgentCli(ctx)) devDeps[AGENT_CLI_PACKAGE] = "0.1.3";
 	if (ctx.config.formatter === "oxfmt") devDeps["oxfmt"] = {
@@ -9535,11 +9543,12 @@ const PLANNING_GUIDE_BODY = [
 	"",
 	"## Working through a plan",
 	"",
-	`Do the tasks in order, commit after each, and tick a box only once its result is verified. Each task starts red -- write its test, watch it fail, make it pass -- and its commit body carries the testing guide's \`${TEST_EVIDENCE_PREFIXES.red}\` or \`${TEST_EVIDENCE_PREFIXES.noTest}\` line. A box you cannot finish keeps its text exactly as written and gets one note underneath:`,
+	`Do the tasks in order, commit after each, and tick a box only once its result is verified. Each task starts red -- write its test, watch it fail, make it pass -- and its commit body carries the testing guide's \`${TEST_EVIDENCE_PREFIXES.red}\` or \`${TEST_EVIDENCE_PREFIXES.noTest}\` line. A box you cannot finish, or cannot finish in full, keeps its text exactly as written and gets one of four notes underneath:`,
 	"",
 	"- `**Progress:**` -- partly done: what landed, what remains, where to pick up. The next pass resumes it.",
 	"- `**Blocked:**` -- tried and failing: the error. The next pass retries it.",
 	"- `**Declined:**` -- must not be done, with the reason: a standing rule, a repo convention, or a check that found it moot. No pass touches it again. \"Too hard\" or \"out of budget\" is Progress, not Declined.",
+	"- `**Deferred:** Task <n> -- <reason>` -- part of the box waits on a later task. Split that box first, so the work that waits is a box of its own, and defer only that one; deferring the whole box drops the part that does not wait. The note says which task and what in it the box waits on, both on that one line. The same plan-only commit adds `- [ ] **Carried from Task <source>:** <the work>` to that task, which is the work going on there; the target cannot be the retire task. The deferral then resolves the box: it says \"later\", not \"never\". With no carried box in the target, nothing is deferred and the box stays outstanding, counted against every later pass.",
 	"",
 	"To run a plan through subagents, see the subagents guide."
 ].join("\n");
@@ -10163,7 +10172,7 @@ function reportFailures(failed, command) {
 function generateMigratePrompt(results, config, detected) {
 	const sections = [];
 	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-	sections.push(`# Migration Prompt\n\n_Generated by \`@bensandee/tooling@0.95.0 repo:sync\` on ${timestamp}_\n`);
+	sections.push(`# Migration Prompt\n\n_Generated by \`@bensandee/tooling@0.96.0 repo:sync\` on ${timestamp}_\n`);
 	const changed = results.filter((r) => r.action === "created" || r.action === "updated" || r.action === "archived");
 	if (changed.length > 0) {
 		const items = changed.map((r) => {
@@ -14139,7 +14148,7 @@ const LabelSchema$1 = z.object({
 	exclusive: z.boolean().optional()
 });
 const LabelListSchema = z.array(LabelSchema$1);
-const LABELS_PAGE_SIZE = 100;
+const LABELS_PAGE_SIZE = 50;
 const LABELS_MAX_PAGES = 20;
 async function fetchAllForgejoLabels(executor, conn) {
 	const labels = [];
@@ -14152,7 +14161,7 @@ async function fetchAllForgejoLabels(executor, conn) {
 		const parsed = LabelListSchema.safeParse(await res.json());
 		if (!parsed.success) throw new UnexpectedError(`Unexpected label-list response: ${parsed.error.message}`);
 		labels.push(...parsed.data);
-		if (parsed.data.length < LABELS_PAGE_SIZE) break;
+		if (!morePagesFollow(res, parsed.data.length, labels.length, LABELS_PAGE_SIZE)) break;
 	}
 	return labels;
 }
@@ -14276,7 +14285,7 @@ async function listForgejoComments(executor, conn, number, options = {}) {
 		}, issueNotFoundMessage(conn, number));
 		const parsed = parseCommentListOrThrow(await res.json());
 		comments.push(...parsed.map(normalizeComment));
-		if (parsed.length < COMMENTS_PAGE_SIZE) break;
+		if (!morePagesFollow(res, parsed.length, comments.length, COMMENTS_PAGE_SIZE)) break;
 		if (page === COMMENTS_MAX_PAGES) {
 			log.warn(`Comment listing for #${String(number)} hit the ${String(COMMENTS_MAX_PAGES)}-page cap; results may be truncated`);
 			options.onPageCap?.();
@@ -14392,7 +14401,10 @@ async function fetchIssueListPage(executor, conn, params) {
 		verb: "list issues",
 		resource: conn.repository
 	}, repoNotFoundMessage(conn));
-	return parseIssueListOrThrow(await res.json());
+	return {
+		raw: parseIssueListOrThrow(await res.json()),
+		res
+	};
 }
 function normalizeDetailedIssues(raw, type) {
 	const normalized = raw.map(normalizeIssue);
@@ -14403,7 +14415,7 @@ const DETAILED_LIST_MAX_PAGES = 20;
 async function listForgejoIssuesDetailedPaged(executor, conn, query, options) {
 	const issues = [];
 	for (let page = 1; page <= DETAILED_LIST_MAX_PAGES; page++) {
-		const raw = await fetchIssueListPage(executor, conn, issueListParams(query.type, {
+		const { raw } = await fetchIssueListPage(executor, conn, issueListParams(query.type, {
 			...query,
 			limit: DETAILED_LIST_PAGE_SIZE,
 			page
@@ -18316,22 +18328,90 @@ function taskLabelId(text) {
 	return `${digits}${match?.[2] ?? ""}`;
 }
 //#endregion
+//#region src/plan-workspace/plan-units.ts
+const AFTER_LABEL = /^[ \t]*(?::|\.|--?)?[ \t]*/;
+function planTask(headingText, label) {
+	const unwrapped = headingText.replace(/^(\*\*|__)/, "").replace(/(\*\*|__)$/, "");
+	return {
+		label,
+		title: unwrapped.slice(unwrapped.indexOf(label) + label.length).replace(AFTER_LABEL, "").trim()
+	};
+}
+function groupPlanUnits(text, boxes) {
+	const lines = text.split("\n");
+	const fenced = fencedLines(lines);
+	const boxAtLine = /* @__PURE__ */ new Map();
+	for (const box of boxes) boxAtLine.set(box.line, box);
+	const units = [];
+	const open = [];
+	for (const [index, rawLine] of lines.entries()) {
+		if (fenced[index] === true) continue;
+		const line = rawLine ?? "";
+		const heading = HEADING.exec(line);
+		if (heading !== null) {
+			const level = (heading[1] ?? "").length;
+			while (open.length > 0 && (open[open.length - 1]?.level ?? 0) >= level) open.pop();
+			const headingText = (heading[2] ?? "").trim();
+			const label = taskLabelId(headingText);
+			if (label === null) continue;
+			const unit = {
+				key: headingText,
+				task: planTask(headingText, label),
+				boxes: []
+			};
+			units.push(unit);
+			open.push({
+				level,
+				unit
+			});
+			continue;
+		}
+		const box = boxAtLine.get(index);
+		if (box === void 0) continue;
+		const section = open[open.length - 1];
+		if (section !== void 0) {
+			section.unit.boxes.push(box);
+			continue;
+		}
+		units.push({
+			key: box.title,
+			task: null,
+			boxes: [box]
+		});
+	}
+	return units;
+}
+//#endregion
 //#region src/plan-workspace/plan-boxes.ts
 const BOX_LINE_REGEX = /^[ \t]*[-*] \[([ xX])\][ \t]*(.*)$/;
 const HEADING_REGEX = /^#{1,6} /;
 const DECLINED_LINE_REGEX = /^[ \t]*(?:[-*][ \t]+)?\*\*Declined:\*\*[ \t]*(.*)$/;
-const NOTE_LINE_REGEX = /^[ \t]*(?:[-*][ \t]+)?\*\*(Progress|Blocked|Declined):\*\*[ \t]*(.*)$/;
+const NOTE_LINE_REGEX = /^[ \t]*(?:[-*][ \t]+)?\*\*(Progress|Blocked|Declined|Deferred):\*\*[ \t]*(.*)$/;
+const DEFERRED_LINE_REGEX = /^[ \t]*(?:[-*][ \t]+)?\*\*Deferred:\*\*[ \t]*(.*)$/;
+const DEFERRAL_SEPARATOR_REGEX = /^[ \t]*(?::|\.|--|-)?[ \t]*/;
 const RETIRE_TASK_REGEX = /^(?:\*\*|__)?Retire this plan(?![A-Za-z0-9])/;
+function describeDeferralCheck(check) {
+	switch (check) {
+		case "empty-reason": return "the note names no reason";
+		case "no-target-label": return "the note names no target task";
+		case "no-own-task": return "the box names no task of its own";
+		case "target-not-found": return "no task in the plan carries that label";
+		case "target-not-later": return "the target task does not come later in the plan";
+		case "target-is-retire": return "the target is the retire task";
+		case "no-carried-box": return "the target task holds no box carried from this one";
+	}
+}
 function isOutstanding(box, options) {
-	if (box.checked || box.declined) return false;
+	if (box.checked || box.declined || box.deferred) return false;
 	return !(box.retireTask && options?.planRetired === true);
 }
 function noteKind(label) {
 	if (label === "Progress") return "progress";
 	if (label === "Blocked") return "blocked";
+	if (label === "Deferred") return "deferred";
 	return "declined";
 }
-const PARAGRAPH_BREAK_REGEX = /^[ \t]*(?:[-*+][ \t]|[0-9]+[.)][ \t]|\*\*(?:Progress|Blocked|Declined):\*\*|<!--)/;
+const PARAGRAPH_BREAK_REGEX = /^[ \t]*(?:[-*+][ \t]|[0-9]+[.)][ \t]|\*\*(?:Progress|Blocked|Declined|Deferred):\*\*|<!--)/;
 const ABBREVIATION_REGEX = /(?:^|[^A-Za-z])(?:e\.g|i\.e|etc|vs|cf)$/i;
 function boxParagraph(lines, fenced, start, end, first) {
 	const parts = [first];
@@ -18365,6 +18445,100 @@ function unwrapEmphasis(rawTitle) {
 	if (emphasis === void 0 || !rawTitle.endsWith(emphasis)) return rawTitle;
 	return rawTitle.slice(emphasis.length, -emphasis.length).trim();
 }
+function deferredLineOf(lines, fenced, start, blockEnd) {
+	for (let index = start + 1; index < blockEnd; index++) {
+		if (fenced[index] === true) continue;
+		const match = DEFERRED_LINE_REGEX.exec(lines[index] ?? "");
+		if (match === null) continue;
+		return (match[1] ?? "").trim();
+	}
+	return null;
+}
+function readDeferralNote(text) {
+	if (text === "") return {
+		target: null,
+		reason: "",
+		failed: "empty-reason"
+	};
+	const target = taskLabelId(text);
+	if (target === null) return {
+		target: null,
+		reason: "",
+		failed: "no-target-label"
+	};
+	const reason = text.slice(text.indexOf(target) + target.length).replace(DEFERRAL_SEPARATOR_REGEX, "").trim();
+	if (reason === "") return {
+		target,
+		reason: "",
+		failed: "empty-reason"
+	};
+	return {
+		target,
+		reason,
+		failed: null
+	};
+}
+function ownTaskLabel(box, units) {
+	const unit = units.find((candidate) => candidate.boxes.some((other) => other.line === box.line));
+	const fromSection = unit?.task?.label ?? null;
+	if (fromSection !== null) return fromSection;
+	return unit?.task === void 0 ? null : taskLabelId(box.title);
+}
+function holdsCarriedBox(unit, sourceLabel) {
+	const escaped = sourceLabel.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const carried = new RegExp(`^Carried from Task ${escaped}(?![0-9A-Za-z]):`);
+	return unit.boxes.some((box) => carried.test(box.title));
+}
+function resolveDeferrals(boxes, units) {
+	for (const { box, deferredLine } of boxes) {
+		if (deferredLine === null || box.checked || box.declined) continue;
+		const deferral = readDeferralNote(deferredLine);
+		box.deferral = deferral;
+		if (deferral.failed !== null || deferral.target === null) continue;
+		const ownIndex = units.findIndex((unit) => unit.boxes.some((other) => other.line === box.line));
+		const sourceLabel = ownTaskLabel(box, units);
+		if (sourceLabel === null) {
+			box.deferral = {
+				...deferral,
+				failed: "no-own-task"
+			};
+			continue;
+		}
+		const targetIndexes = units.flatMap((unit, index) => unit.task?.label === deferral.target ? [index] : []);
+		if (targetIndexes.length !== 1) {
+			box.deferral = {
+				...deferral,
+				failed: "target-not-found"
+			};
+			continue;
+		}
+		const targetIndex = targetIndexes[0] ?? -1;
+		if (targetIndex <= ownIndex) {
+			box.deferral = {
+				...deferral,
+				failed: "target-not-later"
+			};
+			continue;
+		}
+		const target = units[targetIndex];
+		if (target === void 0) continue;
+		if (target.boxes.some((other) => other.retireTask) || target.task !== null && RETIRE_TASK_REGEX.test(target.task.title)) {
+			box.deferral = {
+				...deferral,
+				failed: "target-is-retire"
+			};
+			continue;
+		}
+		if (!holdsCarriedBox(target, sourceLabel)) {
+			box.deferral = {
+				...deferral,
+				failed: "no-carried-box"
+			};
+			continue;
+		}
+		box.deferred = true;
+	}
+}
 function parsePlanBoxes(planText) {
 	const lines = planText.split("\n");
 	const fenced = fencedLines(lines);
@@ -18379,7 +18553,7 @@ function parsePlanBoxes(planText) {
 			rawTitle: (match[2] ?? "").trim()
 		});
 	}
-	return boxStarts.map((box, position) => {
+	const built = boxStarts.map((box, position) => {
 		const nextBoxIndex = boxStarts[position + 1]?.index ?? lines.length;
 		let blockEnd = nextBoxIndex;
 		for (let index = box.index + 1; index < nextBoxIndex; index++) {
@@ -18392,13 +18566,18 @@ function parsePlanBoxes(planText) {
 		const title = stripStrong(unwrapEmphasis(firstSentence$1(boxParagraph(lines, fenced, box.index, blockEnd, box.rawTitle))));
 		const retireTask = RETIRE_TASK_REGEX.test(title);
 		if (box.checked) return {
-			line: box.index,
-			checked: true,
-			declined: false,
-			reason: null,
-			title,
-			retireTask,
-			notes: []
+			box: {
+				line: box.index,
+				checked: true,
+				declined: false,
+				reason: null,
+				title,
+				retireTask,
+				notes: [],
+				deferred: false,
+				deferral: null
+			},
+			deferredLine: null
 		};
 		const notes = [];
 		for (let index = box.index + 1; index < blockEnd; index++) {
@@ -18423,15 +18602,22 @@ function parsePlanBoxes(planText) {
 			}
 		}
 		return {
-			line: box.index,
-			checked: false,
-			declined: reason !== null,
-			reason,
-			title,
-			retireTask,
-			notes
+			box: {
+				line: box.index,
+				checked: false,
+				declined: reason !== null,
+				reason,
+				title,
+				retireTask,
+				notes,
+				deferred: false,
+				deferral: null
+			},
+			deferredLine: deferredLineOf(lines, fenced, box.index, blockEnd)
 		};
 	});
+	if (built.some((entry) => entry.deferredLine !== null)) resolveDeferrals(built, groupPlanUnits(planText, built.map((entry) => entry.box)));
+	return built.map((entry) => entry.box);
 }
 function countOutstandingBoxes(planText, options) {
 	return parsePlanBoxes(planText).filter((box) => isOutstanding(box, options)).length;
@@ -18462,6 +18648,11 @@ function planStatus(planText, planPath) {
 		kind: note.kind,
 		text: note.text
 	})));
+	const deferrals = boxes.flatMap((box) => box.deferral === null ? [] : [{
+		task: box.title,
+		target: box.deferral.target,
+		failed: box.deferral.failed
+	}]);
 	const nextBox = open[0];
 	return {
 		plan: planPath,
@@ -18469,6 +18660,8 @@ function planStatus(planText, planPath) {
 		checked: boxes.filter((box) => box.checked).length,
 		outstanding: open.length,
 		declined: boxes.filter((box) => box.declined).length,
+		deferred: boxes.filter((box) => box.deferred).length,
+		deferrals,
 		next: nextBox === void 0 || nextBox.title === "" ? null : nextBox.title,
 		nextTask: nextBox === void 0 ? null : enclosingTaskLabel(planText, nextBox.line),
 		onlyRetireLeft: open.length > 0 && open.every((box) => box.retireTask),
@@ -18821,7 +19014,7 @@ async function docsSection({ git, docsExtraDirs, resolved }) {
 			path,
 			status: {
 				...status,
-				total: status.checked + status.outstanding + status.declined
+				total: status.checked + status.outstanding + status.declined + status.deferred
 			}
 		});
 	}
@@ -29006,7 +29199,12 @@ function renderStatus(report) {
 	const next = report.next ?? "(none)";
 	const task = report.nextTask === null || taskLabelId(next) === report.nextTask ? "" : `Task ${report.nextTask} -- `;
 	const lines = [`${report.plan}${report.retired ? " (retired)" : ""}: ${String(report.checked)} done, ${String(report.outstanding)} outstanding, ${String(report.declined)} declined`, `next: ${task}${next}${report.onlyRetireLeft ? " -- only the retire task is left" : ""}`];
+	if (report.deferred > 0) lines.splice(1, 0, `${String(report.deferred)} deferred to a later task`);
 	for (const note of report.notes) lines.push(`  [${note.kind}] ${note.task}: ${note.text}`);
+	for (const deferral of report.deferrals) {
+		if (deferral.failed === null) continue;
+		lines.push(`  [deferred -- not counted] ${deferral.task}: ${describeDeferralCheck(deferral.failed)}.`);
+	}
 	return lines.join("\n");
 }
 const planStatusCommand = defineCommand({
@@ -29018,7 +29216,7 @@ const planStatusCommand = defineCommand({
 		plan: PLAN_ARG,
 		json: {
 			type: "boolean",
-			description: "Emit one JSON document: plan, retired, checked, outstanding, declined, next (or null), nextTask (a task label string such as \"3\" or \"18a\", or null), onlyRetireLeft, notes ([{task, kind (progress | blocked | declined), text}]). next is null when there is none; nextTask is null when no task label encloses it."
+			description: "Emit one JSON document: plan, retired, checked, outstanding, declined, deferred, deferrals ([{task, target (a task label string or null), failed (empty-reason | no-target-label | no-own-task | target-not-found | target-not-later | target-is-retire | no-carried-box, or null when valid)}]), next (or null), nextTask (a task label string such as \"3\" or \"18a\", or null), onlyRetireLeft, notes ([{task, kind (progress | blocked | declined | deferred), text}]). next is null when there is none; nextTask is null when no task label encloses it."
 		}
 	},
 	run({ args }) {
@@ -29191,7 +29389,7 @@ async function runCli(config) {
 //#region src/cli-main.ts
 setLogLevel(resolveLogLevel({}));
 setForgejoLogger(log$1);
-const displayVersion = "0.95.0";
+const displayVersion = "0.96.0";
 const bstSubCommands = {
 	"repo:sync": syncCommand,
 	"checks:run": runChecksCommand,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bensandee/tooling",
-  "version": "0.95.0",
+  "version": "0.96.0",
   "description": "CLI tool to bootstrap and maintain standardized TypeScript project tooling",
   "license": "MIT",
   "repository": {

package/tooling.schema.json

@@ -698,7 +698,7 @@
       "additionalProperties": false
     },
     "agent": {
-      "description": "agent:start behaviour overrides. Opt-in: see agent.autonomy for the interior-autonomy gate.",
+      "description": "agent:start behaviour overrides. Opt-in: agent.enabled is the consent gate -- every other key in the block does nothing without it.",
       "type": "object",
       "properties": {
         "enabled": {
@@ -706,7 +706,11 @@
           "type": "boolean"
         },
         "autonomy": {
-          "description": "Opt into interior autonomy (default false). When a phase's latest rationale reports readiness \"ready\" with an empty openQuestions[] and the review phase is clean, the agent applies the existing plan -> implement -> review -> park-at-mergeable advance itself instead of parking for a human. Never applies to the design/spec gate or the final merge from the mergeable terminal -- those always wait on a human. Also arms the trunk-red detector: when this repo's default branch combined status settles red, the agent files a tracking issue naming the failing checks and labels it agent/spec, starting the fix through the ordinary spec/plan/implement/review pipeline. It also closes that issue, with a comment, if the default branch recovers on its own before a human acts on it. Also arms the world-changed retrigger sweep: a pull request labelled agent-flags/autopilot that is parked at a -stuck or -failed terminal is re-queued when the fact its park recorded stops being true (the default branch went green, or moved past a conflicted base).",
+          "description": "Retired and ignored -- it armed neither the advance rung nor the sweeps it once did. Advance is now the unit's own `agent-flags/advance` or `agent-flags/autopilot` label, and the trunk-red detector and world-changed retrigger sweep read `agent.trunkRed`. The key is still accepted so an existing config keeps syncing; the agent warns once per launch for a repo that still sets it.",
+          "type": "boolean"
+        },
+        "trunkRed": {
+          "description": "Whether this repo's trunk-red detector and world-changed retrigger sweep run (default: on). The detector files a tracking issue when the default branch's combined status settles red and labels it agent/spec, and closes that issue with a comment if the branch recovers on its own before a human acts on it. The retrigger sweep re-queues a pull request labelled agent-flags/autopilot parked at a -stuck or -failed terminal when the fact its park recorded stops being true (the default branch went green, or moved past a conflicted base). A missing key means on; false disarms both.",
           "type": "boolean"
         },
         "preRunRebase": {