@pmelab/gtd 2.6.0 → 2.8.0

package/bin/gtd-loop

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-# Drives the two-beat protocol (README.md "The reference loop driver") to a
+# Drives the two-beat protocol (docs/loop.md "The reference loop driver") to a
 # human gate. Both mutators are attempted every iteration, refusal-tolerant:
 # whichever actor is actually awaited claims the turn (captures the human's
 # uncommitted edit after a halt, or the agent's own edit from the previous

package/dist/gtd.bundle.mjs

@@ -189138,6 +189138,7 @@ const DEFAULT_TEST_COMMAND = "npm run test";
 const DEFAULT_AGENTIC_REVIEW = true;
 const DEFAULT_SQUASH = true;
 const DEFAULT_LEARNING = true;
+const DEFAULT_DECISION_LOG = true;
 const DEFAULT_FIX_ATTEMPT_CAP = 3;
 const DEFAULT_REVIEW_THRESHOLD = 3;
 const ModelStatesSchema = Struct({
@@ -189160,6 +189161,7 @@ const ConfigSchema = Struct({
 	agenticReview: optional(Boolean$),
 	squash: optional(Boolean$),
 	learning: optional(Boolean$),
+	decisionLog: optional(Boolean$),
 	fixAttemptCap: optional(Int.pipe(greaterThanOrEqualTo(0))),
 	reviewThreshold: optional(Int.pipe(greaterThanOrEqualTo(1)))
 });
@@ -189300,6 +189302,7 @@ const toOperations = (decoded) => {
 		agenticReview: decoded.agenticReview ?? DEFAULT_AGENTIC_REVIEW,
 		squash: decoded.squash ?? DEFAULT_SQUASH,
 		learning: decoded.learning ?? DEFAULT_LEARNING,
+		decisionLog: decoded.decisionLog ?? DEFAULT_DECISION_LOG,
 		fixAttemptCap: decoded.fixAttemptCap ?? DEFAULT_FIX_ATTEMPT_CAP,
 		reviewThreshold: decoded.reviewThreshold ?? DEFAULT_REVIEW_THRESHOLD
 	};
@@ -351781,6 +351784,7 @@ const parseReviewDoc = (content) => {
 const GTD_DIR = ".gtd";
 const TODO_FILE = `${GTD_DIR}/TODO.md`;
 const ARCHITECTURE_FILE = `${GTD_DIR}/ARCHITECTURE.md`;
+const PLAN_FILE = `${GTD_DIR}/PLAN.md`;
 const REVIEW_FILE = `${GTD_DIR}/REVIEW.md`;
 const FEEDBACK_FILE = `${GTD_DIR}/FEEDBACK.md`;
 const ERRORS_FILE = `${GTD_DIR}/ERRORS.md`;
@@ -351792,6 +351796,7 @@ const LEGACY_FEEDBACK_FILE = "FEEDBACK.md";
 const STEERING_FILES = {
 	todo: TODO_FILE,
 	architecture: ARCHITECTURE_FILE,
+	plan: PLAN_FILE,
 	review: REVIEW_FILE,
 	feedback: FEEDBACK_FILE,
 	errors: ERRORS_FILE,
@@ -351972,6 +351977,25 @@ const subjectOf$1 = (message) => (message.split("\n")[0] ?? "").trim();
 * keeps pre-namespaced history classifying identically.
 */
 const touchedFeedback = (touched) => touched.includes(FEEDBACK_FILE) || touched.includes(LEGACY_FEEDBACK_FILE);
+const DECISIONS_TRAILER_RE = /^Gtd-Decisions:\s*true\s*$/m;
+const DECISIONS_HEADING = "## Decisions";
+/**
+* Extracts one commit message's `## Decisions` section verbatim (heading
+* through the next `#`/`##` heading or end of message, trailer line
+* excluded), or `undefined` when the trailer is absent or the heading can't
+* be found despite it (a malformed historical commit — skipped, not an
+* error, since this reads commits the current turn doesn't own and can't be
+* asked to fix). Total, never throws.
+*/
+const extractDecisionsSection = (message) => {
+	if (!DECISIONS_TRAILER_RE.test(message)) return void 0;
+	const lines = message.split(/\r?\n/);
+	const headingIdx = lines.findIndex((line) => line.trim() === DECISIONS_HEADING);
+	if (headingIdx === -1) return void 0;
+	const endIdx = lines.findIndex((line, i) => i > headingIdx && /^#{1,2}\s+\S/.test(line.trim()));
+	const section = lines.slice(headingIdx, endIdx === -1 ? lines.length : endIdx).filter((line) => !DECISIONS_TRAILER_RE.test(line)).join("\n").trim();
+	return section.length > 0 ? section : void 0;
+};
 /**
 * Gather ALL git/filesystem facts and produce the typed event stream the pure
 * machine folds: one `COMMIT` per first-parent commit (oldest→newest) followed
@@ -351992,18 +352016,21 @@ const gatherEvents = (invoker) => gen(function* () {
 		const parsed = parseSubject(subjectOf$1(commit.message));
 		const isTurn = parsed.kind === "turn";
 		const isRouting = parsed.kind === "routing";
+		const routingPhase = parsed.kind === "routing" ? parsed.phase : "";
+		const turnGate = parsed.kind === "turn" ? parsed.gate : "";
 		return {
 			type: "COMMIT",
-			...isTurn ? {
+			...parsed.kind === "turn" ? {
 				turnActor: parsed.actor,
 				turnGate: parsed.gate
 			} : {},
-			isErrors: isRouting && parsed.phase === "errors",
-			isFeedback: isTurn && parsed.gate === "agentic-review" && touchedFeedback(commit.touched),
-			isPackageStart: isRouting && (parsed.phase === "planning" || parsed.phase === "package-done"),
+			isErrors: routingPhase === "errors",
+			isFeedback: turnGate === "agentic-review" && touchedFeedback(commit.touched),
+			isPackageStart: routingPhase === "planning" || routingPhase === "package-done",
 			isWorkflowCommit: isTurn || isRouting,
 			removedErrors: commit.removedErrors,
-			isHealthCheck: isRouting && parsed.phase === "health-check"
+			isHealthCheck: routingPhase === "health-check",
+			isTestsGreen: routingPhase === "tests-green"
 		};
 	});
 	const hasCommits = yield* git.hasCommits();
@@ -352036,6 +352063,7 @@ const gatherEvents = (invoker) => gen(function* () {
 	const codeDirty = entries.some((e) => !isGtdPath(e.path));
 	const todoExists = yield* fs.exists(resolve(TODO_FILE));
 	const architectureExists = yield* fs.exists(resolve(ARCHITECTURE_FILE));
+	const planExists = yield* fs.exists(resolve(PLAN_FILE));
 	const reviewPresent = yield* fs.exists(resolve(REVIEW_FILE));
 	const feedbackPresent = yield* fs.exists(resolve(FEEDBACK_FILE));
 	const errorsPresent = yield* fs.exists(resolve(ERRORS_FILE));
@@ -352051,6 +352079,7 @@ const gatherEvents = (invoker) => gen(function* () {
 	const reviewDirty = reviewTrackedAtHead && !workingTreeClean;
 	const todoCommitted = todoExists && !isUncommitted(TODO_FILE);
 	const architectureCommitted = architectureExists && !isUncommitted(ARCHITECTURE_FILE);
+	const planCommitted = planExists && !isUncommitted(PLAN_FILE);
 	const grillingDocPath = todoExists ? TODO_FILE : architectureExists ? ARCHITECTURE_FILE : void 0;
 	const grillingDocErrors = grillingDocPath ? parseOpenQuestions(yield* fs.readFileString(resolve(grillingDocPath))).errors : [];
 	const reviewDocErrors = reviewPresent ? parseReviewDoc(yield* fs.readFileString(resolve(REVIEW_FILE))).errors : [];
@@ -352062,8 +352091,10 @@ const gatherEvents = (invoker) => gen(function* () {
 	let refDiff;
 	let reviewAnchor;
 	let hasCommitsAfterLastDone = true;
+	let decisionLog = "";
 	if (hasCommits) {
 		const allHistory = isNone(base) ? history : yield* git.commitHistory();
+		if (config.decisionLog) decisionLog = allHistory.map((c) => extractDecisionsSection(c.message)).filter((section) => section !== void 0).join("\n\n");
 		const lastDoneIdx = (() => {
 			let idx = -1;
 			for (let i = 0; i < allHistory.length; i++) if (subjectOf$1(allHistory[i].message) === DONE_SUBJECT) idx = i;
@@ -352077,7 +352108,7 @@ const gatherEvents = (invoker) => gen(function* () {
 		}
 		const isGrillingTurn = (message) => {
 			const parsed = parseSubject(subjectOf$1(message));
-			return parsed.kind === "turn" && (parsed.gate === "grilling" || parsed.gate === "architecting");
+			return parsed.kind === "turn" && (parsed.gate === "grilling" || parsed.gate === "architecting" || parsed.gate === "grilled");
 		};
 		const firstGrilling = currentCycle.find((c) => isGrillingTurn(c.message));
 		const lastAwaitingReview = (() => {
@@ -352117,7 +352148,7 @@ const gatherEvents = (invoker) => gen(function* () {
 			const squashCycle = squashHistory.slice(prevDoneIdx + 1, lastDoneIdxForSquash + 1);
 			const isGrillingTurnSubject = (subject) => {
 				const parsed = parseSubject(subject);
-				return parsed.kind === "turn" && (parsed.gate === "grilling" || parsed.gate === "architecting");
+				return parsed.kind === "turn" && (parsed.gate === "grilling" || parsed.gate === "architecting" || parsed.gate === "grilled");
 			};
 			const isReviewingAnchor = (subject) => {
 				const parsed = parseSubject(subject);
@@ -352152,28 +352183,23 @@ const gatherEvents = (invoker) => gen(function* () {
 	const healthCommitted = healthPresent && !isUncommitted(HEALTH_FILE);
 	let healthFixBase;
 	if (config.squash || config.learning) {
-		let firstHealthCheckHash;
-		let healthCheckCount = 0;
-		for (const commit of commitEvents) {
-			if (commit.isPackageStart || commit.removedErrors) {
-				firstHealthCheckHash = void 0;
-				healthCheckCount = 0;
-			}
-			if (commit.isHealthCheck) healthCheckCount++;
-		}
-		if (healthCheckCount > 0) {
-			let resetAt = -1;
-			for (let i = 0; i < history.length; i++) {
-				const c = commitEvents[i];
-				if (c.isPackageStart || c.removedErrors) resetAt = i;
-			}
-			for (let i = resetAt + 1; i < history.length; i++) if (commitEvents[i].isHealthCheck) {
-				firstHealthCheckHash = history[i].hash;
-				break;
+		const inHealthProcessingChain = headParsedForSquash.kind === "routing" && (headParsedForSquash.phase === "tests-green" || headParsedForSquash.phase === "learning-template" || headParsedForSquash.phase === "learning-drafted" || headParsedForSquash.phase === "learning-approved" || headParsedForSquash.phase === "squash-template" || headParsedForSquash.phase === "learning-applied" && config.squash) || headParsedForSquash.kind === "turn" && SQUASH_OR_LEARNING_TURN_GATES.has(headParsedForSquash.gate);
+		let lastTestsGreenIdx = -1;
+		for (let i = 0; i < commitEvents.length; i++) if (commitEvents[i].isTestsGreen) lastTestsGreenIdx = i;
+		const ignoredTestsGreenIdx = inHealthProcessingChain ? lastTestsGreenIdx : -1;
+		const isHealthEntryTurn = (c) => c.turnActor === "human" && c.turnGate === "health-fixing";
+		let anchorIdx = -1;
+		for (let i = 0; i < commitEvents.length; i++) {
+			const c = commitEvents[i];
+			if (c.isPackageStart || c.removedErrors || c.isTestsGreen && i !== ignoredTestsGreenIdx) {
+				anchorIdx = -1;
+				continue;
 			}
+			if (anchorIdx === -1 && (c.isHealthCheck || isHealthEntryTurn(c))) anchorIdx = i;
 		}
-		if (healthCheckCount > 0 && firstHealthCheckHash !== void 0) {
-			const healthBase = yield* git.resolveRef(`${firstHealthCheckHash}~1`).pipe(catchAll(() => succeed$3(EMPTY_TREE)));
+		if (anchorIdx !== -1) {
+			const anchorHash = history[anchorIdx].hash;
+			const healthBase = yield* git.resolveRef(`${anchorHash}~1`).pipe(catchAll(() => succeed$3(EMPTY_TREE)));
 			healthFixBase = healthBase;
 			const healthCandidateDiff = yield* git.diffRef(healthBase).pipe(catchAll(() => succeed$3("")));
 			if (healthCandidateDiff.trim().length > 0) {
@@ -352193,6 +352219,8 @@ const gatherEvents = (invoker) => gen(function* () {
 			todoCommitted,
 			architectureExists,
 			architectureCommitted,
+			planExists,
+			planCommitted,
 			packagesPresent: packages.length > 0,
 			reviewPresent,
 			feedbackPresent,
@@ -352230,7 +352258,8 @@ const gatherEvents = (invoker) => gen(function* () {
 			...healthFixBase !== void 0 ? { healthFixBase } : {},
 			learningEnabled: config.learning,
 			learningMsgPresent,
-			learningMsgIsTemplate
+			learningMsgIsTemplate,
+			decisionLog
 		}
 	};
 	return [...commitEvents, resolveEvent];
@@ -352324,6 +352353,13 @@ const SQUASH_TEMPLATE = [
 */
 const ARCHITECTURE_SEED_BANNER = "<!-- gtd: seeded from the converged product plan (.gtd/TODO.md); decide the technical/architectural questions below. -->\n\n";
 /**
+* Banner prepended to `.gtd/ARCHITECTURE.md` when it is seeded from a
+* hand-written `.gtd/PLAN.md` (the direct-to-decompose entry) — same
+* orientation role as `ARCHITECTURE_SEED_BANNER`, one phase later: the plan
+* is final, the next turn decomposes it.
+*/
+const ARCHITECTURE_PLAN_SEED_BANNER = "<!-- gtd: seeded from the final plan (.gtd/PLAN.md); decompose into ordered work packages. -->\n\n";
+/**
 * A short skeleton written by `writeLearningTemplate`, instructing the
 * learning agent to replace it with the real distilled learnings.
 */
@@ -352354,8 +352390,11 @@ const perform = (action) => gen(function* () {
 	const ensureGtdDir = fs.makeDirectory(resolve(GTD_DIR), { recursive: true }).pipe(catchAll(() => _void));
 	switch (action.kind) {
 		case "captureTurn":
-			if (yield* fs.exists(resolve(TODO_FILE))) yield* formatFile(resolve(TODO_FILE)).pipe(catchAll(() => _void));
-			if (yield* fs.exists(resolve(ARCHITECTURE_FILE))) yield* formatFile(resolve(ARCHITECTURE_FILE)).pipe(catchAll(() => _void));
+			for (const file of [
+				TODO_FILE,
+				ARCHITECTURE_FILE,
+				PLAN_FILE
+			]) if (yield* fs.exists(resolve(file))) yield* formatFile(resolve(file)).pipe(catchAll(() => _void));
 			yield* git.commitAllWithPrefix(turnSubject(action.actor, action.gate));
 			return { stop: false };
 		case "commitRouting":
@@ -352365,6 +352404,12 @@ const perform = (action) => gen(function* () {
 				yield* fs.writeFileString(resolve(ARCHITECTURE_FILE), ARCHITECTURE_SEED_BANNER + todoContent);
 				yield* fs.remove(resolve(TODO_FILE)).pipe(catchAll(() => _void));
 			}
+			if (action.seedArchitectureFromPlan === true) {
+				const planContent = yield* fs.readFileString(resolve(PLAN_FILE)).pipe(catchAll(() => succeed$3("")));
+				yield* ensureGtdDir;
+				yield* fs.writeFileString(resolve(ARCHITECTURE_FILE), ARCHITECTURE_PLAN_SEED_BANNER + planContent);
+				yield* fs.remove(resolve(PLAN_FILE)).pipe(catchAll(() => _void));
+			}
 			if (action.removeArchitecture === true) yield* fs.remove(resolve(ARCHITECTURE_FILE)).pipe(catchAll(() => _void));
 			if (action.removeReview === true) yield* fs.remove(resolve(REVIEW_FILE)).pipe(catchAll(() => _void));
 			if (action.removeFeedback === true) yield* fs.remove(resolve(FEEDBACK_FILE)).pipe(catchAll(() => _void));
@@ -352456,7 +352501,7 @@ const counterRules = {
 		incrementsOn: (e) => e.isFeedback
 	},
 	healthFixCount: {
-		resetsOn: (e) => e.isPackageStart || e.removedErrors,
+		resetsOn: (e) => e.isPackageStart || e.removedErrors || e.isTestsGreen,
 		incrementsOn: (e) => e.isHealthCheck
 	}
 };
@@ -352508,6 +352553,8 @@ const DEFAULT_PAYLOAD = {
 	todoCommitted: false,
 	architectureExists: false,
 	architectureCommitted: false,
+	planExists: false,
+	planCommitted: false,
 	packagesPresent: false,
 	reviewPresent: false,
 	feedbackPresent: false,
@@ -352537,7 +352584,8 @@ const DEFAULT_PAYLOAD = {
 	healthCommitted: false,
 	learningEnabled: false,
 	learningMsgPresent: false,
-	learningMsgIsTemplate: false
+	learningMsgIsTemplate: false,
+	decisionLog: ""
 };
 /** Build the prompt context from the payload passthrough + the folded counters. */
 const buildContext = (p, counters) => ({
@@ -352549,7 +352597,8 @@ const buildContext = (p, counters) => ({
 	...p.squashBase !== void 0 ? { squashBase: p.squashBase } : {},
 	...p.squashDiff !== void 0 ? { squashDiff: p.squashDiff } : {},
 	feedbackContent: p.feedbackContent !== "" ? p.feedbackContent : p.healthContent,
-	...p.headTurnDiff !== "" ? { turnDiff: p.headTurnDiff } : {}
+	...p.headTurnDiff !== "" ? { turnDiff: p.headTurnDiff } : {},
+	decisionLog: p.decisionLog
 });
 const healthFileConflictRules = [
 	{
@@ -352567,6 +352616,52 @@ const healthFileConflictRules = [
 	{
 		isViolated: (p) => p.healthPresent && p.errorsPresent,
 		message: ".gtd/HEALTH.md + .gtd/ERRORS.md"
+	},
+	{
+		isViolated: (p) => p.healthPresent && p.todoExists,
+		message: ".gtd/HEALTH.md + .gtd/TODO.md"
+	},
+	{
+		isViolated: (p) => p.healthPresent && p.architectureExists,
+		message: ".gtd/HEALTH.md + .gtd/ARCHITECTURE.md"
+	},
+	{
+		isViolated: (p) => p.healthPresent && p.planExists,
+		message: ".gtd/HEALTH.md + .gtd/PLAN.md"
+	}
+];
+const planFileConflictRules = [
+	{
+		isViolated: (p) => p.planExists && p.todoExists,
+		message: ".gtd/PLAN.md + .gtd/TODO.md"
+	},
+	{
+		isViolated: (p) => p.planExists && p.architectureExists,
+		message: ".gtd/PLAN.md + .gtd/ARCHITECTURE.md"
+	},
+	{
+		isViolated: (p) => p.planExists && p.packagesPresent,
+		message: ".gtd/PLAN.md + packages"
+	},
+	{
+		isViolated: (p) => p.planExists && p.reviewPresent,
+		message: ".gtd/PLAN.md + .gtd/REVIEW.md"
+	},
+	{
+		isViolated: (p) => p.planExists && p.feedbackPresent,
+		message: ".gtd/PLAN.md + .gtd/FEEDBACK.md"
+	},
+	{
+		isViolated: (p) => p.planExists && p.errorsPresent,
+		message: ".gtd/PLAN.md + .gtd/ERRORS.md"
+	},
+	{
+		isViolated: (p) => p.planExists && p.squashMsgPresent,
+		message: ".gtd/PLAN.md + .gtd/SQUASH_MSG.md"
+	},
+	{
+		isViolated: (p) => p.planExists && p.learningMsgPresent,
+		message: ".gtd/PLAN.md + .gtd/LEARNINGS.md"
 	}
 ];
 const learningFileConflictRules = [
@@ -352662,6 +352757,7 @@ const assertLegal = (p) => {
 	for (const rule of [
 		...healthFileConflictRules,
 		...learningFileConflictRules,
+		...planFileConflictRules,
 		...reviewAndFeedbackRules
 	]) if (rule.isViolated(p)) throw new GtdStateError("illegal-combination", `illegal combination: ${rule.message}`);
 };
@@ -352791,6 +352887,16 @@ const classifyHead = (subject, flags) => {
 				actor: "agent"
 			};
 		}
+		if (actor === "human" && gate === "grilled") return flags.planExists ? {
+			kind: "mid-chain",
+			state: "grilled",
+			actor: "agent",
+			action: {
+				kind: "commitRouting",
+				subject: "gtd: grilled",
+				seedArchitectureFromPlan: true
+			}
+		} : null;
 		if (actor === "agent" && gate === "grilled") return flags.hasPackages ? {
 			kind: "mid-chain",
 			state: "grilled",
@@ -353037,7 +353143,11 @@ const gateForState = (state) => STATE_IS_OWN_GATE.has(state) ? state : GATE_OVER
 * (CLAUDE.md/AGENTS.md/docs), so it's unconditionally inert on a clean tree,
 * same as `building`/`fixing`. `health-fixing` is deliberately absent: its
 * empty turn is meaningful (environmental fix; the machine removes
-* HEALTH.md and re-tests).
+* HEALTH.md and re-tests) — EXCEPT while HEAD is the human's hand-written
+* HEALTH.md entry turn (`gtd(human): health-fixing`), where the loop
+* protocol's opening clean-tree `gtd step-agent` would otherwise consume the
+* human's error description before any agent read it (see
+* `isInertEmptyAgentRest`).
 */
 const INERT_EMPTY_AGENT_GATES = /* @__PURE__ */ new Set([
 	"grilling",
@@ -353050,11 +353160,20 @@ const INERT_EMPTY_AGENT_GATES = /* @__PURE__ */ new Set([
 	"learning-apply"
 ]);
 /**
+* HEAD is the human's HEALTH.md entry turn (`gtd(human): health-fixing`) —
+* the hand-written error description was just captured and no agent has
+* acted on it yet.
+*/
+const isHumanHealthEntryHead = (head) => {
+	const parsed = parseSubject(head);
+	return parsed.kind === "turn" && parsed.actor === "human" && parsed.gate === "health-fixing";
+};
+/**
 * True when a `step-agent` invocation at this rest has nothing to capture —
 * see `INERT_EMPTY_AGENT_GATES`. Shared by `applyTurnTaking` (author nothing)
 * and `predictTurn` (predict null) so the two can never disagree.
 */
-const isInertEmptyAgentRest = (state, p) => p.workingTreeClean && (INERT_EMPTY_AGENT_GATES.has(state) || state === "squashing" && p.squashMsgIsTemplate || state === "learning" && p.learningMsgIsTemplate);
+const isInertEmptyAgentRest = (state, p) => p.workingTreeClean && (INERT_EMPTY_AGENT_GATES.has(state) || state === "squashing" && p.squashMsgIsTemplate || state === "learning" && p.learningMsgIsTemplate || state === "health-fixing" && isHumanHealthEntryHead(p.lastCommitSubject));
 /**
 * The baseline decision: classify HEAD, falling through to the payload-driven
 * ladder for the rows `classifyHead` cannot resolve alone (boundary subjects,
@@ -353105,6 +353224,7 @@ const resolveBaseline = (p, counters, head, corrupt, lastTurn) => {
 	const flags = {
 		headTurnIsEmpty: p.headTurnIsEmpty,
 		hasPackages: p.packagesPresent,
+		planExists: p.planExists,
 		agenticReviewForceApproved: forceApprove,
 		squashEnabled: p.squashEnabled,
 		hasSquashBase: p.squashBase !== void 0,
@@ -353171,6 +353291,11 @@ const resolveBaseline = (p, counters, head, corrupt, lastTurn) => {
 		state: "architecting",
 		actor: "agent"
 	};
+	if (p.planExists) return {
+		kind: "rest",
+		state: "grilled",
+		actor: "human"
+	};
 	if (p.packagesPresent && p.packages.length > 0 && lastTurn?.actor === "agent" && lastTurn.gate === "building") return {
 		kind: "mid-chain",
 		state: "building",
@@ -353181,7 +353306,7 @@ const resolveBaseline = (p, counters, head, corrupt, lastTurn) => {
 			capReached: false
 		}
 	};
-	if (!p.packagesPresent && !p.reviewPresent && !p.feedbackPresent && !p.errorsPresent && !p.healthPresent && !p.todoExists && !p.architectureExists) return resolveIdleOrHealth(p);
+	if (!p.packagesPresent && !p.reviewPresent && !p.feedbackPresent && !p.errorsPresent && !p.healthPresent && !p.todoExists && !p.architectureExists && !p.planExists) return resolveIdleOrHealth(p);
 	return corrupt();
 };
 /** Boundary/idle lifecycle: no steering files, unrecognized or absent workflow HEAD. */
@@ -353206,8 +353331,8 @@ const resolveIdleOrHealth = (p) => {
 const applyTurnTaking = (p, counters, head, baseline) => {
 	const context = buildContext(p, counters);
 	const invoker = p.invoker;
-	if (invoker === "human" && !p.workingTreeClean && !p.todoCommitted && !p.architectureCommitted && !p.packagesPresent && !p.reviewPresent && !p.feedbackPresent && !p.errorsPresent && !p.healthPresent && (parseSubject(head).kind === "boundary" || head === "gtd: done")) {
-		const entryGate = p.architectureExists ? "architecting" : "grilling";
+	if (invoker === "human" && !p.workingTreeClean && !p.todoCommitted && !p.architectureCommitted && !p.planCommitted && !p.packagesPresent && !p.reviewPresent && !p.feedbackPresent && !p.errorsPresent && !p.healthCommitted && (parseSubject(head).kind === "boundary" || head === "gtd: done")) {
+		const entryGate = p.healthPresent ? "health-fixing" : p.planExists ? "grilled" : p.architectureExists ? "architecting" : "grilling";
 		return {
 			state: entryGate,
 			actor: "human",
@@ -353244,7 +353369,7 @@ const applyTurnTaking = (p, counters, head, baseline) => {
 	};
 	const healthCheckCapReached = head === "gtd: health-check" && counters.healthFixCount >= p.fixAttemptCap;
 	if (head === "gtd: health-fix" && baseline.state === "idle" || healthCheckCapReached && baseline.state === "health-fixing") {
-		const chainAfterGreenAtHealthFix = (p.squashEnabled || p.learningEnabled) && counters.healthFixCount > 0 && p.healthFixBase !== void 0;
+		const chainAfterGreenAtHealthFix = (p.squashEnabled || p.learningEnabled) && p.healthFixBase !== void 0;
 		return {
 			state: "idle",
 			actor: "agent",
@@ -353266,7 +353391,7 @@ const applyTurnTaking = (p, counters, head, baseline) => {
 		context
 	};
 	if (baseline.state === "idle" && invoker === "human") {
-		const chainAfterGreen = (p.squashEnabled || p.learningEnabled) && counters.healthFixCount > 0 && p.healthFixBase !== void 0;
+		const chainAfterGreen = (p.squashEnabled || p.learningEnabled) && p.healthFixBase !== void 0;
 		return {
 			state: "idle",
 			actor: "human",
@@ -353374,8 +353499,8 @@ const predictTurn = (events) => {
 			state: baseline.state
 		};
 	}
-	if (!payload.workingTreeClean && !payload.todoCommitted && !payload.architectureCommitted && !payload.packagesPresent && !payload.reviewPresent && !payload.feedbackPresent && !payload.errorsPresent && !payload.healthPresent && (parseSubject(head).kind === "boundary" || head === "gtd: done")) {
-		const entryGate = payload.architectureExists ? "architecting" : "grilling";
+	if (!payload.workingTreeClean && !payload.todoCommitted && !payload.architectureCommitted && !payload.planCommitted && !payload.packagesPresent && !payload.reviewPresent && !payload.feedbackPresent && !payload.errorsPresent && !payload.healthCommitted && (parseSubject(head).kind === "boundary" || head === "gtd: done")) {
+		const entryGate = payload.healthPresent ? "health-fixing" : payload.planExists ? "grilled" : payload.architectureExists ? "architecting" : "grilling";
 		return {
 			actor: "human",
 			subject: `gtd(human): ${entryGate}`,
@@ -353910,17 +354035,20 @@ var feedback_default = "<%\n  const body = it.content.replace(/\\n$/, \"\")\n  c
 //#region src/prompts/partials/package.md
 var package_default = "<%\n  const lines = [\"\", \"### Package: `\" + it.pkg.name + \"/`\", \"\"]\n  for (const task of it.pkg.taskContents) {\n    const fence = it.fenceFor(task.content)\n    lines.push(\"#### `\" + task.name + \"`\", \"\", fence, task.content.replace(/\\n$/, \"\"), fence, \"\")\n  }\n%><%~ lines.join(\"\\n\") %>\n";
 //#endregion
+//#region src/prompts/partials/decision-log.md
+var decision_log_default = "<%\n  const body = it.decisionLog.replace(/\\n$/, \"\")\n  const fence = it.fenceFor(body)\n  const out = [\n    \"\",\n    \"### Prior decisions\",\n    \"\",\n    \"Recorded in past squash commits, oldest to newest, with no deduplication\" +\n      \" — if two entries answer the same question differently, the LATER one\" +\n      \" (further down) is the current, authoritative answer. Don't re-ask a\" +\n      \" settled question unless the codebase now genuinely contradicts it.\",\n    \"\",\n    fence,\n    body,\n    fence,\n    \"\",\n  ].join(\"\\n\")\n%><%~ out %>\n";
+//#endregion
 //#region src/prompts/partials/agent-turn.md
 var agent_turn_default = "Finish your turn by running `gtd step-agent`. Then run `gtd next` and follow\nits output — repeat this cycle as long as the output is addressed to you (the\nagent); when it awaits the human, stop and hand off.\n";
 //#endregion
 //#region src/prompts/grilling-agent.md
-var grilling_agent_default = "<%~ include(\"@header\") %>\n\n`.gtd/TODO.md` holds the plan under development. Develop it into a concrete,\nproduct-level plan **in this one turn** — use subagents / internal iteration\nto go as deep as needed; there is no further agent-only round after this one.\n\n**Scope: product and user-facing decisions only.** Do not decide\nimplementation details in this file — file/module structure, data models,\nlibrary or tech-stack choices, and other architecture questions belong to the\nnext phase (`.gtd/ARCHITECTURE.md`) and must not be treated as open questions\nhere.\n\n### Develop the plan\n\nSpawn a **planning-model subagent** using model `<%= it.model %>` to develop the plan.\nThe subagent works entirely by editing `.gtd/TODO.md`:\n\n1. **Explore the codebase before asking anything** — read the relevant files,\n   tests, and docs so every question below is one the codebase genuinely\n   cannot answer.\n2. **Replace the captured input / seed template with a real product plan** —\n   what to build and why, and the user-facing behavior it should have,\n   grounded in the codebase. Leave *how* to build it for the next phase.\n3. **Iterate internally** (spawn further subagents, reconsider, cross-check)\n   until the plan is as complete as it can get without human input. Do not\n   leave this to a future round — there isn't one before the human is asked.\n4. For every remaining open question, add it under a `## Open Questions`\n   section near the top of the file, one `### <question>` sub-heading per\n   question, whose first body line is `Suggested default: <answer>` — your\n   best-guess answer, stated plainly, that the human can accept as-is. This\n   structure is enforced: a `###` question with no `Suggested default:` line\n   blocks your turn — `gtd step-agent` refuses until it's fixed. Omit the\n   `## Open Questions` section entirely once there are none.\n5. Leave `.gtd/TODO.md` **uncommitted** — the human's turn (`gtd step`) reads it\n   next.\n<% if (it.context.turnDiff && it.context.turnDiff.trim()) { %>\n<%~ include(\"@diff\", { heading: \"Latest human input (answers / sketch / review feedback)\", diff: it.context.turnDiff, fenceFor: it.fenceFor }) %>\n\nRead the diff above as **feedback, not finished work**:\n\n- Code changes are suggestions — fold them into the plan and re-implement them\n  properly, including test coverage, rather than restoring them verbatim.\n- Code comments are positional feedback about the code at that location.\n- Plan-text changes are global feedback on the plan (or the reviewed work) as\n  a whole.\n<% } %>\n\n<% if (it.tail) { %>\n<%~ include(it.tail) %>\n<% } %>\n";
+var grilling_agent_default = "<%~ include(\"@header\") %>\n\n`.gtd/TODO.md` holds the plan under development. Develop it into a concrete,\nproduct-level plan **in this one turn** — use subagents / internal iteration\nto go as deep as needed; there is no further agent-only round after this one.\n\n**Scope: product and user-facing decisions only.** Do not decide\nimplementation details in this file — file/module structure, data models,\nlibrary or tech-stack choices, and other architecture questions belong to the\nnext phase (`.gtd/ARCHITECTURE.md`) and must not be treated as open questions\nhere.\n<% if (it.context.decisionLog && it.context.decisionLog.trim()) { %>\n<%~ include(\"@decision-log\", { decisionLog: it.context.decisionLog, fenceFor: it.fenceFor }) %>\n<% } %>\n\n### Develop the plan\n\nSpawn a **planning-model subagent** using model `<%= it.model %>` to develop the plan.\nThe subagent works entirely by editing `.gtd/TODO.md`:\n\n1. **Explore the codebase before asking anything** — read the relevant files,\n   tests, and docs so every question below is one the codebase genuinely\n   cannot answer.\n2. **Replace the captured input / seed template with a real product plan** —\n   what to build and why, and the user-facing behavior it should have,\n   grounded in the codebase. Leave *how* to build it for the next phase.\n3. **Iterate internally** (spawn further subagents, reconsider, cross-check)\n   until the plan is as complete as it can get without human input. Do not\n   leave this to a future round — there isn't one before the human is asked.\n4. For every remaining open question, add it under a `## Open Questions`\n   section near the top of the file, one `### <question>` sub-heading per\n   question, whose first body line is `Suggested default: <answer>` — your\n   best-guess answer, stated plainly, that the human can accept as-is. This\n   structure is enforced: a `###` question with no `Suggested default:` line\n   blocks your turn — `gtd step-agent` refuses until it's fixed. Omit the\n   `## Open Questions` section entirely once there are none.\n5. Leave `.gtd/TODO.md` **uncommitted** — the human's turn (`gtd step`) reads it\n   next.\n<% if (it.context.turnDiff && it.context.turnDiff.trim()) { %>\n<%~ include(\"@diff\", { heading: \"Latest human input (answers / sketch / review feedback)\", diff: it.context.turnDiff, fenceFor: it.fenceFor }) %>\n\nRead the diff above as **feedback, not finished work**:\n\n- Code changes are suggestions — fold them into the plan and re-implement them\n  properly, including test coverage, rather than restoring them verbatim.\n- Code comments are positional feedback about the code at that location.\n- Plan-text changes are global feedback on the plan (or the reviewed work) as\n  a whole.\n<% } %>\n\n<% if (it.tail) { %>\n<%~ include(it.tail) %>\n<% } %>\n";
 //#endregion
 //#region src/prompts/grilling-answers.md
 var grilling_answers_default = "<%~ include(\"@header\") %>\n\n`.gtd/TODO.md` holds the plan under development, with open questions under a\n`## Open Questions` section — each `### <question>` carrying a suggested\ndefault.\n\nThis is a human gate; there is nothing for the agent to do.\n\nTell the user:\n\n- To answer a question, edit its `### <question>` entry under `## Open\n  Questions` in place — replace the `Suggested default: ...` line with\n  `Answer: ...` (or annotate it further), then run `gtd step`.\n- To accept **all** suggested defaults as-is, run `gtd step` with **no\n  edits** — this converges the plan and moves on to technical architecting.\n\n<% if (it.tail) { %>\n<%~ include(it.tail) %>\n<% } %>\n";
 //#endregion
 //#region src/prompts/architecting-agent.md
-var architecting_agent_default = "<%~ include(\"@header\") %>\n\n`.gtd/ARCHITECTURE.md` holds the technical plan under development — seeded\nfrom the converged product plan, or, if this is the very first turn on\nalready-technical input, written directly by the human. Develop it into a concrete,\nimplementation-ready technical plan **in this one turn** — use subagents /\ninternal iteration to go as deep as needed; there is no further agent-only\nround after this one.\n\n**Scope: technical/architectural decisions only.** Decide file/module\nstructure, data models, module boundaries, library or tech-stack choices, and\nerror-handling/concurrency strategy — the *how*, building on the *what*\nalready settled in this file's product content. Do not re-open or re-litigate\nproduct/user-facing decisions from the prior phase; treat them as settled\ncontext.\n\n### Develop the architecture\n\nSpawn a **planning-model subagent** using model `<%= it.model %>` to develop the\narchitecture. The subagent works entirely by editing `.gtd/ARCHITECTURE.md`:\n\n1. **Explore the codebase before asking anything** — read the relevant files,\n   tests, and docs so every question below is one the codebase genuinely\n   cannot answer.\n2. **Replace the seeded/captured content with a real architecture** — the\n   files to change, module/data-model structure, and why, grounded in the\n   codebase.\n3. **Iterate internally** (spawn further subagents, reconsider, cross-check)\n   until the architecture is as complete as it can get without human input.\n   Do not leave this to a future round — there isn't one before the human is\n   asked.\n4. For every remaining open question, add it under a `## Open Questions`\n   section near the top of the file, one `### <question>` sub-heading per\n   question, whose first body line is `Suggested default: <answer>` — your\n   best-guess answer, stated plainly, that the human can accept as-is. This\n   structure is enforced: a `###` question with no `Suggested default:` line\n   blocks your turn — `gtd step-agent` refuses until it's fixed. Omit the\n   `## Open Questions` section entirely once there are none.\n5. Leave `.gtd/ARCHITECTURE.md` **uncommitted** — the human's turn (`gtd step`)\n   reads it next.\n<% if (it.context.turnDiff && it.context.turnDiff.trim()) { %>\n<%~ include(\"@diff\", { heading: \"Latest human input (answers / sketch / review feedback)\", diff: it.context.turnDiff, fenceFor: it.fenceFor }) %>\n\nRead the diff above as **feedback, not finished work**:\n\n- Code changes are suggestions — fold them into the architecture and\n  re-implement them properly, including test coverage, rather than restoring\n  them verbatim.\n- Code comments are positional feedback about the code at that location.\n- Plan-text changes are global feedback on the architecture (or the reviewed\n  work) as a whole.\n<% } %>\n\n<% if (it.tail) { %>\n<%~ include(it.tail) %>\n<% } %>\n";
+var architecting_agent_default = "<%~ include(\"@header\") %>\n\n`.gtd/ARCHITECTURE.md` holds the technical plan under development — seeded\nfrom the converged product plan, or, if this is the very first turn on\nalready-technical input, written directly by the human. Develop it into a concrete,\nimplementation-ready technical plan **in this one turn** — use subagents /\ninternal iteration to go as deep as needed; there is no further agent-only\nround after this one.\n\n**Scope: technical/architectural decisions only.** Decide file/module\nstructure, data models, module boundaries, library or tech-stack choices, and\nerror-handling/concurrency strategy — the *how*, building on the *what*\nalready settled in this file's product content. Do not re-open or re-litigate\nproduct/user-facing decisions from the prior phase; treat them as settled\ncontext.\n<% if (it.context.decisionLog && it.context.decisionLog.trim()) { %>\n<%~ include(\"@decision-log\", { decisionLog: it.context.decisionLog, fenceFor: it.fenceFor }) %>\n<% } %>\n\n### Develop the architecture\n\nSpawn a **planning-model subagent** using model `<%= it.model %>` to develop the\narchitecture. The subagent works entirely by editing `.gtd/ARCHITECTURE.md`:\n\n1. **Explore the codebase before asking anything** — read the relevant files,\n   tests, and docs so every question below is one the codebase genuinely\n   cannot answer.\n2. **Replace the seeded/captured content with a real architecture** — the\n   files to change, module/data-model structure, and why, grounded in the\n   codebase.\n3. **Iterate internally** (spawn further subagents, reconsider, cross-check)\n   until the architecture is as complete as it can get without human input.\n   Do not leave this to a future round — there isn't one before the human is\n   asked.\n4. For every remaining open question, add it under a `## Open Questions`\n   section near the top of the file, one `### <question>` sub-heading per\n   question, whose first body line is `Suggested default: <answer>` — your\n   best-guess answer, stated plainly, that the human can accept as-is. This\n   structure is enforced: a `###` question with no `Suggested default:` line\n   blocks your turn — `gtd step-agent` refuses until it's fixed. Omit the\n   `## Open Questions` section entirely once there are none.\n5. Leave `.gtd/ARCHITECTURE.md` **uncommitted** — the human's turn (`gtd step`)\n   reads it next.\n<% if (it.context.turnDiff && it.context.turnDiff.trim()) { %>\n<%~ include(\"@diff\", { heading: \"Latest human input (answers / sketch / review feedback)\", diff: it.context.turnDiff, fenceFor: it.fenceFor }) %>\n\nRead the diff above as **feedback, not finished work**:\n\n- Code changes are suggestions — fold them into the architecture and\n  re-implement them properly, including test coverage, rather than restoring\n  them verbatim.\n- Code comments are positional feedback about the code at that location.\n- Plan-text changes are global feedback on the architecture (or the reviewed\n  work) as a whole.\n<% } %>\n\n<% if (it.tail) { %>\n<%~ include(it.tail) %>\n<% } %>\n";
 //#endregion
 //#region src/prompts/architecting-answers.md
 var architecting_answers_default = "<%~ include(\"@header\") %>\n\n`.gtd/ARCHITECTURE.md` holds the technical plan under development, with open\nquestions under a `## Open Questions` section — each `### <question>`\ncarrying a suggested default.\n\nThis is a human gate; there is nothing for the agent to do.\n\nTell the user:\n\n- To answer a question, edit its `### <question>` entry under `## Open\n  Questions` in place — replace the `Suggested default: ...` line with\n  `Answer: ...` (or annotate it further), then run `gtd step`.\n- To accept **all** suggested defaults as-is, run `gtd step` with **no\n  edits** — this converges the architecture and moves on to decomposition.\n\n<% if (it.tail) { %>\n<%~ include(it.tail) %>\n<% } %>\n";
@@ -353935,7 +354063,7 @@ var building_default = "<%~ include(\"@header\") %>\n\nBuild the package describ
 var fixing_default = "<%~ include(\"@header\") %>\n\nSpawn a **fix subagent** using model `<%= it.model %>` to apply fixes for the feedback\nbelow:\n\n1. **Work through the Feedback to address section below** — address every item\n   it lists. For test output, make the failing tests pass; for review findings,\n   satisfy each finding against the package's task specs.\n2. **Make the fix in place** — change the code to resolve the feedback. Keep the\n   change focused; do not refactor unrelated code.\n3. **Or dispute the feedback** — if a finding is wrong, empty or delete\n   `.gtd/FEEDBACK.md` instead of fixing it. The machine picks the dispute up\n   either way.\n4. **Leave every change uncommitted and finish your turn** — do **not** commit\n   or stage.\n<% if (it.context.feedbackContent.trim()) { %>\n<%~ include(\"@feedback\", { content: it.context.feedbackContent, fenceFor: it.fenceFor }) %>\n<% } %>\n\n<% if (it.tail) { %>\n<%~ include(it.tail) %>\n<% } %>\n";
 //#endregion
 //#region src/prompts/health-fixing.md
-var health_fixing_default = "<%~ include(\"@header\") %>\n\nThe idle health check failed — the repository's test suite is red outside any\nwork cycle. Spawn a **fix subagent** using model `<%= it.model %>` to repair\nit:\n\n1. **Work through the failure output below** — make the failing test command\n   pass again.\n2. **Make the fix in place** — keep the change focused; do not refactor\n   unrelated code.\n3. **If the failure does not reproduce** (or nothing needs changing), change\n   nothing and simply finish your turn — the machine re-runs the health check\n   either way.\n4. **Never create or edit any file under `.gtd/`** — in particular, do NOT\n   write `.gtd/FEEDBACK.md`. The machine removes `.gtd/HEALTH.md` itself when\n   your turn is captured.\n5. **Leave every change uncommitted and finish your turn** — do **not** commit\n   or stage.\n<% if (it.context.feedbackContent.trim()) { %>\n<%~ include(\"@feedback\", { content: it.context.feedbackContent, fenceFor: it.fenceFor }) %>\n<% } %>\n\n<% if (it.tail) { %>\n<%~ include(it.tail) %>\n<% } %>\n";
+var health_fixing_default = "<%~ include(\"@header\") %>\n\nThe repository's health gate is red outside any work cycle — either the idle\nhealth check failed, or a human hand-wrote `.gtd/HEALTH.md` describing errors\nto fix. Spawn a **fix subagent** using model `<%= it.model %>` to repair it:\n\n1. **Work through the report below** — fix the described errors and make the\n   test command pass.\n2. **Make the fix in place** — keep the change focused; do not refactor\n   unrelated code.\n3. **If the failure does not reproduce** (or nothing needs changing), change\n   nothing and simply finish your turn — the machine re-runs the health check\n   either way.\n4. **Never create or edit any file under `.gtd/`** — in particular, do NOT\n   write `.gtd/FEEDBACK.md`. The machine removes `.gtd/HEALTH.md` itself when\n   your turn is captured.\n5. **Leave every change uncommitted and finish your turn** — do **not** commit\n   or stage.\n<% if (it.context.feedbackContent.trim()) { %>\n<%~ include(\"@feedback\", { content: it.context.feedbackContent, fenceFor: it.fenceFor }) %>\n<% } %>\n\n<% if (it.tail) { %>\n<%~ include(it.tail) %>\n<% } %>\n";
 //#endregion
 //#region src/prompts/agentic-review.md
 var agentic_review_default = "<%~ include(\"@header\") %>\n\nSpawn a **reviewing subagent** using model `<%= it.model %>`. The package's task spec\nfiles and its cumulative diff are found below. The subagent must:\n\n1. **Read the task spec files** — they define the acceptance criteria. Every\n   requirement must be checked, with one exception: ignore any spec\n   requirement about files under `.gtd/` (or a root-level `TODO.md` /\n   `REVIEW.md` / `FEEDBACK.md` acting as workflow state). Those files are\n   managed by the workflow machine — created and deleted outside the\n   implementation's control — so never report a finding about their\n   presence, absence, or content.\n2. **Read the package diff** — examine every hunk to determine whether the\n   implementation satisfies the spec.\n3. **Always write `.gtd/FEEDBACK.md`**:\n   - **Fully satisfies the spec** → write an **empty** `.gtd/FEEDBACK.md` (zero bytes\n     or whitespace only). This empty file is the **approval** signal.\n   - **Does not fully satisfy** → write concrete, actionable findings anchored\n     to specific file and symbol names, grouped under short headings, so the fix\n     agent can act without re-reading the diff.\n4. **Do not edit source files and do not commit** — the reviewer only writes\n   `.gtd/FEEDBACK.md`, left uncommitted, then finishes its turn.\n<% if (it.context.packages[0]) { %>\n<%~ include(\"@package\", { pkg: it.context.packages[0], fenceFor: it.fenceFor }) %>\n<% } %><% if (it.context.refDiff && it.context.refDiff.trim()) { %>\n<%~ include(\"@diff\", { heading: \"Package diff\", diff: it.context.refDiff, fenceFor: it.fenceFor }) %>\n<% } %>\n\n<% if (it.tail) { %>\n<%~ include(it.tail) %>\n<% } %>\n";
@@ -353947,7 +354075,7 @@ var review_default = "<%~ include(\"@header\") %>\n\nSpawn a **planning-model su
 var await_review_default = "<%~ include(\"@header\") %>\n\n`.gtd/REVIEW.md` holds the review record for the completed work. This is a human\ngate; there is nothing for the agent to do.\n\nTell the user:\n\n- Read `.gtd/REVIEW.md` (and the underlying work it points at).\n- To **approve**: run `gtd step` with no edits, or only tick checkboxes in\n  `.gtd/REVIEW.md` — either way ends the review with an approval.\n- To **request changes**: write substantive edits or annotations into\n  `.gtd/REVIEW.md` (or the code) describing what's wrong, then run `gtd step` —\n  this sends the feedback back for another round.\n\n<% if (it.tail) { %>\n<%~ include(it.tail) %>\n<% } %>\n";
 //#endregion
 //#region src/prompts/squashing.md
-var squashing_default = "<%~ include(\"@header\") %>\n\nThe process is **approved and done**. `.gtd/SQUASH_MSG.md` has already been\ncommitted with a template — your job is to overwrite it with the real\nconventional-commits squash message and finish your turn.\n\n### Step 1 — Extract decisions from grilling rounds\n\nScan the git history of recent `gtd: ...` / `gtd(agent): ...` /\n`gtd(human): ...` commits. Look for changes to `.gtd/TODO.md` and\n`.gtd/ARCHITECTURE.md` — specifically the `## Captured input` sections and any\nedits to plan/architecture text. Extract **key decisions, trade-offs, and\ndesign choices** made during grilling and architecting rounds. These will\nappear in the commit body so the history is self-documenting.\n\n### Step 2 — Draft the commit message\n\nDraft ONE conventional-commits message:\n\n```\ntype(scope): subject\n\nbody (explain the why — motivation, trade-offs, key decisions from grilling)\n```\n\n- **type**: `feat` / `fix` / `refactor` / `chore` / `docs` / `test`\n- **subject**: imperative mood, ≤ 72 characters, lowercase after the colon\n- **body**: include the important decisions / trade-offs from grilling\n  sessions. Omit if there were no meaningful decisions to capture.\n\n### Step 3 — Overwrite .gtd/SQUASH_MSG.md\n\nReplace the **entire content** of `.gtd/SQUASH_MSG.md` (plain text, no markdown\nwrapper, no leftover template scaffolding) with the message from Step 2, then\nleave it uncommitted and finish your turn — `gtd step-agent` performs the\nsquash using this file's content.\n<% if (it.context.squashDiff && it.context.squashDiff.trim()) { %>\n<%= it.context.squashBase !== undefined ? \"\\nSquash base: \" + it.context.squashBase + \"\\n\" : \"\" %>\n<%~ include(\"@diff\", { heading: \"Full-process diff (`git diff \" + (it.context.squashBase !== undefined ? it.context.squashBase : \"<squashBase>\") + \" HEAD`)\", diff: it.context.squashDiff, fenceFor: it.fenceFor }) %>\n<% } %>\n\n<% if (it.tail) { %>\n<%~ include(it.tail) %>\n<% } %>\n";
+var squashing_default = "<%~ include(\"@header\") %>\n\nThe process is **approved and done**. `.gtd/SQUASH_MSG.md` has already been\ncommitted with a template — your job is to overwrite it with the real\nconventional-commits squash message and finish your turn.\n\n### Step 1 — Extract decisions from grilling rounds\n\nScan the git history of recent `gtd: ...` / `gtd(agent): ...` /\n`gtd(human): ...` commits. Look for changes to `.gtd/TODO.md` and\n`.gtd/ARCHITECTURE.md` — specifically the `## Captured input` sections and any\nedits to plan/architecture text. Extract **key decisions, trade-offs, and\ndesign choices** made during grilling and architecting rounds — specifically\nthe `### <question>` entries under `## Open Questions` that got resolved\n(`Answer:`, or an accepted `Suggested default:`) this cycle.\n\n### Step 2 — Draft the commit message\n\nDraft ONE conventional-commits message:\n\n```\ntype(scope): subject\n\nbody (explain the why — motivation, trade-offs, key decisions from grilling)\n\n## Decisions\n\n### <question, verbatim from Step 1>\nAnswer: <the resolved answer> (default accepted | human override: <reason>)\n\nGtd-Decisions: true\n```\n\n- **type**: `feat` / `fix` / `refactor` / `chore` / `docs` / `test`\n- **subject**: imperative mood, ≤ 72 characters, lowercase after the colon\n- **body**: a brief motivation/trade-off summary.\n- **`## Decisions`**: one block per question resolved THIS cycle (from Step\n  1) — omit the whole section (and the `Gtd-Decisions: true` line) entirely\n  when this cycle recorded no decisions. Don't restate decisions from earlier\n  cycles — this commit only records what changed now; a later grilling round\n  reads the full history of these sections back as context, so repeating old\n  entries here would just duplicate them forever. If this cycle's answer\n  contradicts an earlier cycle's, don't try to edit or annotate the old one —\n  just state the new answer plainly; the newer commit naturally reads as the\n  current truth.\n\n### Step 3 — Overwrite .gtd/SQUASH_MSG.md\n\nReplace the **entire content** of `.gtd/SQUASH_MSG.md` (plain text, no markdown\nwrapper, no leftover template scaffolding) with the message from Step 2, then\nleave it uncommitted and finish your turn — `gtd step-agent` performs the\nsquash using this file's content.\n<% if (it.context.squashDiff && it.context.squashDiff.trim()) { %>\n<%= it.context.squashBase !== undefined ? \"\\nSquash base: \" + it.context.squashBase + \"\\n\" : \"\" %>\n<%~ include(\"@diff\", { heading: \"Full-process diff (`git diff \" + (it.context.squashBase !== undefined ? it.context.squashBase : \"<squashBase>\") + \" HEAD`)\", diff: it.context.squashDiff, fenceFor: it.fenceFor }) %>\n<% } %>\n\n<% if (it.tail) { %>\n<%~ include(it.tail) %>\n<% } %>\n";
 //#endregion
 //#region src/prompts/learning.md
 var learning_default = "<%~ include(\"@header\") %>\n\nThe process is **approved and done**, and headed for a squash. Before that\nhappens, `.gtd/LEARNINGS.md` has been committed with a template — your job is\nto overwrite it with the real, distilled learnings from this cycle so they\nsurvive the squash even though the granular history won't.\n\n### Step 1 — Walk the cycle's history\n\nScan the git history back to the cycle's start (the full-process diff is\ninlined below, and `git log` over the same range shows every `gtd: ...` /\n`gtd(agent): ...` / `gtd(human): ...` commit). Look specifically for:\n\n- **Test failures and fixes** — each `gtd: errors` round and the fix that\n  followed it. What broke, and what actually made it pass?\n- **Review feedback** — human `.gtd/REVIEW.md` notes and `gtd: review\n  feedback` detours. What did the human have to correct that the agent got\n  wrong on its own?\n- **Health-check rounds** — any `gtd: health-check` / `gtd: health-fix`\n  cycles. Environmental or systemic issues surfaced outside normal building?\n- **Grilling decisions** — `.gtd/TODO.md`'s \"## Captured input\" sections and\n  plan edits. Trade-offs or conventions the human specified that a future\n  agent should already know.\n\n### Step 2 — Distill, don't transcribe\n\nFor each thing you found, ask: is this a **durable, generalizable lesson**\n(a convention, a gotcha, a pattern this project wants followed next time), or\na **one-off detail** specific to this change? Keep only the former. A future\nagent reading this should learn something that changes how it works on this\nproject, not a recap of what happened.\n\n### Step 3 — Overwrite .gtd/LEARNINGS.md\n\nReplace the **entire content** of `.gtd/LEARNINGS.md` with your distilled\nlearnings (plain markdown, no leftover template scaffolding). If nothing\ndurable surfaced this cycle, write a short explicit note saying so — don't\nleave the placeholder text in place. Leave the file uncommitted and finish\nyour turn; a human reviews it next before it's integrated into the project's\nown memory (CLAUDE.md/AGENTS.md/docs).\n<% if (it.context.squashDiff && it.context.squashDiff.trim()) { %>\n<%= it.context.squashBase !== undefined ? \"\\nCycle base: \" + it.context.squashBase + \"\\n\" : \"\" %>\n<%~ include(\"@diff\", { heading: \"Full-process diff (`git diff \" + (it.context.squashBase !== undefined ? it.context.squashBase : \"<squashBase>\") + \" HEAD`)\", diff: it.context.squashDiff, fenceFor: it.fenceFor }) %>\n<% } %>\n\n<% if (it.tail) { %>\n<%~ include(it.tail) %>\n<% } %>\n";
@@ -354034,6 +354162,7 @@ eta.loadTemplate("@header", header_default);
 eta.loadTemplate("@diff", diff_default);
 eta.loadTemplate("@feedback", feedback_default);
 eta.loadTemplate("@package", package_default);
+eta.loadTemplate("@decision-log", decision_log_default);
 eta.loadTemplate("@agent-turn", agent_turn_default);
 eta.loadTemplate("@grilling-agent", grilling_agent_default);
 eta.loadTemplate("@grilling-answers", grilling_answers_default);
@@ -365108,7 +365237,7 @@ const reviewWindowBase = (history) => {
 		const parsed = parseSubject(subjectOf(c.message));
 		if (parsed.kind === "routing" && parsed.phase === "reviewing" && parsed.param !== void 0) anchor = parsed.param;
 		if (parsed.kind === "routing" && parsed.phase === "awaiting-review") lastAwaitingReview = c.hash;
-		if (parsed.kind === "turn" && parsed.gate === "grilling" && firstGrilling === void 0) firstGrilling = c.hash;
+		if (parsed.kind === "turn" && (parsed.gate === "grilling" || parsed.gate === "architecting" || parsed.gate === "grilled") && firstGrilling === void 0) firstGrilling = c.hash;
 	}
 	return anchor ?? lastAwaitingReview ?? firstGrilling;
 };
@@ -365445,6 +365574,7 @@ const edgeActionHandlers = {
 	commitRouting: (a) => {
 		let msg = `commit routing as "${a.subject}"`;
 		if (a.seedArchitectureFromTodo) msg += " (seeding .gtd/ARCHITECTURE.md from .gtd/TODO.md)";
+		if (a.seedArchitectureFromPlan) msg += " (seeding .gtd/ARCHITECTURE.md from .gtd/PLAN.md)";
 		const removed = [];
 		if (a.removeArchitecture) removed.push(".gtd/ARCHITECTURE.md");
 		if (a.removeReview) removed.push(".gtd/REVIEW.md");