@pmelab/gtd 2.6.0 → 2.7.0

package/README.md

@@ -39,6 +39,11 @@ or `REVIEW.md` at the repository root is the project's own file — gtd never
 reads, consumes, or deletes it. (Corollary: don't gitignore `.gtd/` — the
 workflow commits its state through it.)
 
+A squash commit's message can carry a `## Decisions` section — one entry per
+architecture/product question resolved that cycle. Grilling/architecting read
+every past squash commit's `## Decisions` section back as "Prior decisions"
+context, oldest to newest. See `decisionLog` under Configuration.
+
 ## Quick start: the two-beat loop
 
 gtd splits what used to be one mutating command into three:
@@ -750,19 +755,20 @@ With `squash: true` (the default), `gtd: done` (or, once learning has run,
 to `gtd: squash template`, writing and committing a `.gtd/SQUASH_MSG.md`
 template. `gtd next` then emits the squashing prompt: the agent overwrites
 `.gtd/SQUASH_MSG.md` with a real conventional-commits message (drawing on
-grilling- and architecting-round decisions from history) and finishes its turn.
-`gtd step-agent` then performs the squash itself: `git reset --soft <base>` +
-`git commit`, collapsing every intermediate `gtd: *` commit of the cycle into
-one — including any review-feedback detours, and the learning phase's own
-commits if learning ran: the squash base is the cycle's ORIGINAL start (the
-first grilling or, via the escape hatch, architecting turn since the previous
-`gtd: done` boundary, or the `gtd: reviewing <hash>` anchor for an ad-hoc review
-cycle), not the most recent re-grilling round — the collapse folds the whole
-cycle into one, using the overwritten message's content verbatim (turn position,
-not message content, triggers the squash). Doc edits made during
-`learning-apply` survive in the squashed tree, not as their own commit. With
-`squash: false`, `gtd: done` (or `gtd: learning applied`) is the resting
-boundary and no template is ever written.
+grilling- and architecting-round decisions from history, and, when this cycle
+resolved any open questions, a `## Decisions` section recording them) and
+finishes its turn. `gtd step-agent` then performs the squash itself:
+`git reset --soft <base>` + `git commit`, collapsing every intermediate `gtd: *`
+commit of the cycle into one — including any review-feedback detours, and the
+learning phase's own commits if learning ran: the squash base is the cycle's
+ORIGINAL start (the first grilling or, via the escape hatch, architecting turn
+since the previous `gtd: done` boundary, or the `gtd: reviewing <hash>` anchor
+for an ad-hoc review cycle), not the most recent re-grilling round — the
+collapse folds the whole cycle into one, using the overwritten message's content
+verbatim (turn position, not message content, triggers the squash). Doc edits
+made during `learning-apply` survive in the squashed tree, not as their own
+commit. With `squash: false`, `gtd: done` (or `gtd: learning applied`) is the
+resting boundary and no template is ever written.
 
 ### Health check
 
@@ -849,6 +855,10 @@ built-in defaults apply. Supported filenames (searched in this order):
   `.gtd/LEARNINGS.md`, have a human review them, then integrate them into the
   project's own docs before the squash decision runs. Set `false` to skip the
   phase entirely — independent of `squash`.
+- **`decisionLog`** (boolean, default `true`) — squashing records this cycle's
+  resolved open questions as a `## Decisions` section in the squash commit
+  message; grilling/architecting inline every past squash commit's section,
+  oldest to newest, as prior-decision context. Set `false` to skip both.
 - **`models`** — model selection for the subagent-spawning states:
   - `planning` — high-reasoning tier (default `claude-opus-4-8`), used by
     `decompose` (the `grilled`/`planning` states), `grilling`, `architecting`,
@@ -913,6 +923,7 @@ reviewThreshold: 3
 agenticReview: true
 squash: true
 learning: true
+decisionLog: true
 models:
   planning: claude-opus-4-8
   execution: claude-sonnet-4-8

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
 	};
@@ -351972,6 +351975,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
@@ -352062,8 +352084,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;
@@ -352230,7 +352254,8 @@ const gatherEvents = (invoker) => gen(function* () {
 			...healthFixBase !== void 0 ? { healthFixBase } : {},
 			learningEnabled: config.learning,
 			learningMsgPresent,
-			learningMsgIsTemplate
+			learningMsgIsTemplate,
+			decisionLog
 		}
 	};
 	return [...commitEvents, resolveEvent];
@@ -352537,7 +352562,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 +352575,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 = [
 	{
@@ -353910,17 +353937,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";
@@ -353947,7 +353977,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 +354064,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);

package/package.json

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

package/schema.json

@@ -63,6 +63,9 @@
     "learning": {
       "type": "boolean"
     },
+    "decisionLog": {
+      "type": "boolean"
+    },
     "fixAttemptCap": {
       "$ref": "#/$defs/Int",
       "description": "a non-negative number",