gsd-pi 2.78.1-dev.eccf86e27 → 2.79.0-dev.579e14e9b

package/README.md

@@ -27,54 +27,95 @@ One command. Walk away. Come back to a built project with clean git history.
 
 ---
 
-## What's New in v2.78
+## What's New in v2.79
 
-### Worktree Lifecycle & Forensics
+### DB-Authoritative Runtime State
 
-- **Slice-cadence worktree collapse (#4765)** — new `git.collapse_cadence: "milestone" | "slice"` preference. With `slice`, each validated slice squash-merges to main immediately, shrinking the orphan window from milestone-size to slice-size. Pair with `git.milestone_resquash: true` to collapse per-slice commits into one milestone commit at completion.
-- **Worktree telemetry (#4764)** — new journal events (`worktree-created`, `worktree-merged`, `worktree-orphaned`, `auto-exit`, `canonical-root-redirect`, `slice-merged`, `milestone-resquash`) and a `summarizeWorktreeTelemetry` aggregator that reports orphan breakdowns, merge durations, conflict counts, exit reasons, and unmerged-exit metrics.
-- **`/gsd forensics` worktree section** — surfaces the telemetry above with two new anomalies: `worktree-orphan` and `worktree-unmerged-exit`.
-- **Worktree-aware canonical milestone root (#4761)** — `resolveCanonicalMilestoneRoot` routes validators and cross-session readers through the live worktree, so milestone validation no longer silently reads stale project-root state.
-- **Bootstrap orphan audit (#4762)** — in-progress milestones with commits ahead of main no longer get skipped; the audit emits a warning with commit count and worktree location so interrupted auto-runs are visible.
+- **Auto-mode coordination tables (#5247)** — workers, leases, dispatches, and a command queue are now first-class DB rows, replacing ad-hoc files for cross-process auto coordination.
+- **`auto.lock` + `paused-session.json` → DB (#5250)** — phase C pt 2 of the runtime-state migration. The on-disk lockfile and paused-session JSON are gone; lock acquisition, stale-lock detection, and pause state all live in `gsd.db`.
+- **Stuck-state migration (#5249)** — `copyPlanningArtifacts` / `reconcile` deleted; auto-mode writers canonicalize through the DB instead of mirroring artifacts to disk.
+- **`gsd headless recover`** — non-TTY DB recovery command for unattended environments where the interactive recover flow can't run.
+- **Doctor surfaces DB locks** — `gsd doctor` reports DB-backed stale locks and flags exhausted `run-uat` retry counters so wedged runs are visible without log archaeology.
 
-### Auto Pipeline & Component System
+### Workspace & Worktree Isolation
 
-- **Unified component system** — skills, agents, pipelines, and marketplace are now one component model wired through runtime, dispatch, and telemetry, replacing per-surface plumbing.
-- **UnitContextManifest v2 (#4924, #4934)** — auto dispatch runs through a typed manifest with declarative tools-policy and typed computed artifacts. CI guards the schema so drift fails fast.
-- **Composer migration phase 3 (#4782)** — `complete-slice`, `research-milestone`, `run-uat`, and `reassess-roadmap` now build context through the manifest composer for a consistent shape across units.
-- **Milestone scope classifier + pipeline variants (#4781)** — auto picks a pipeline variant from milestone shape, so research-heavy and execution-heavy milestones no longer share a one-size dispatch path.
-- **Per-unit-type skill manifest resolver (#4779)** — skills wire into specific unit types instead of being globally on, with manifests expanded across the remaining types.
-- **Single-writer-v3 control plane** — closes outstanding gaps in the durable-state writer model so concurrent writers can't desync workflow state.
-- **Opt-in `reassess-roadmap` (#4778)** — gated behind the `skip_clean_reassess` preference per ADR-003 §4; auto no longer triggers reassessment unprompted.
+- **`GsdWorkspace` + `MilestoneScope` handle types** — workspace identity is now an explicit handle threaded through writers, metrics, and the DB connection instead of a module singleton.
+- **Symlink-safe canonicalization** — `deriveState` read root and cache key are canonicalized; path normalization unified on `realpathSync.native`; `gsdRootCache` keys normalized and decoupled from per-turn cache clears; `git-root` anchor guarded against `~/.gsd` resolution.
+- **Worktree-scoped DB + metrics** — `gsd-db` connections and metrics ledgers are scoped by workspace identity, so concurrent milestones in separate worktrees can't cross-contaminate state.
+- **Worktree cwd anchoring** — subagent dispatch anchors to the canonical worktree path, `mergeAndExit` anchors cwd at project root (closes [#5079](https://github.com/gsd-build/GSD-2/issues/5079)), MCP cwd is hardened against drift, and dispatch stops on cwd anchor failures.
+- **Slice isolation through resolver (#5246)** — slice merge isolation routed through the worktree resolver; `originalBase` checks use `isSamePath` instead of string equality; `auto-worktree` validates `milestoneId` match in `ByScope` wrappers.
+- **Worktree CLI commands** — `gsd worktree {list, merge, clean, remove}` exposed in the TUI dispatcher.
 
-### Extensions Framework
+### Deep Planning Mode (Phase 11)
 
-- **Extension lifecycle commands** — `gsd extensions install / update / uninstall / list / info / validate` for npm, git, and local sources, with dependency warnings and user-metadata tracking.
-- **Topological extension load order** — Kahn's-algorithm sort with surfaced `ExtensionLoadWarning`s, so dependent extensions resolve deterministically and misconfigurations are visible instead of silent.
-- **cmux ↔ gsd decoupling** — static cross-imports replaced with a shared `cmux-events` contract and dynamic imports, isolating extension boundaries.
-- **Extracted `@gsd-extensions/google-search` workspace** — first reference extension carved out of core; legacy in-tree source replaced with a deprecation stub.
+- **`/gsd new-project --deep`** — opt-in deep mode for new projects, with `research-decision` and `research-project` dispatch units, deep-mode artifact validators, and gated approval flows that pause the milestone instead of aborting on grounding/discovery questions.
+- **EVAL-REVIEW system** — `/gsd eval-review` command, frontmatter schema, pre-ship soft warning when EVAL-REVIEW status is incomplete, and registration in the catalog + ops dispatcher.
+- **Project-shape-aware discuss depth** — discuss-phase questioning depth scales via the project-shape classifier; tiny apps cap research and auto-skip stale research blockers; deep research is opt-in and blocked while a marker is in flight.
+- **Approval-gate hardening** — deep approval gates verified, opening interview question protected from approval abort, plain-text setup approvals gated, deep setup state guarded against phantom transitions.
 
-### Models, Agent, and UX
+### Auto Pipeline & Dispatch
 
-- **GPT-5.5 Codex support** — added across `gsd` and `pi-ai`, including `xhigh` thinking level for custom GPT-5.5 models.
-- **Auth mode in `/model`** — providers display alongside auth mode for clearer routing.
-- **Permission granularity picker** — Claude Code "Always Allow" prompts let you scope the grant instead of approving the broad case.
-- **Headless auto default → `bypassPermissions` (#4657)** — Claude Code CLI headless auto-mode runs without permission prompts by default.
-- **`skillFilter` for system prompts** — `pi-coding-agent` filters which skills are surfaced in `buildSystemPrompt`, with consumer exceptions guarded.
-- **Visual postinstall (#4641)** — install shows a spinner/banner UX so first-run state is legible.
-- **PR-risk verification** — risk prompt emits a copy-pasteable code block to make follow-up commands one step.
+- **Delegation-policy verdicts** — dispatch actions are annotated with a per-tool background-safety policy verdict; the policy itself is codified instead of inferred per call.
+- **Reactive-execute default** — auto-dispatch defaults to reactive-execute when ≥3 ready tasks are queued, replacing the always-sequential fallback.
+- **Proactive rate limiting (#2996)** — `min_request_interval_ms` preference paces auto-mode requests; the interval is stamped at dispatch.
+- **Manifest-driven skill surfacing** — `auto-prompts` surfaces manifest skills via recommendations + auto-match; planning-dispatch mode added to the unit manifest for slice plan/complete; runtime tools-policy enforced for planning units (#4934).
+- **Subagent telemetry** — dispatch telemetry, stronger prompt guidelines, and model-override threading (`??` consistently used for `modelOverride`).
 
-### Reliability & Safety
+### MCP, Models & Cross-Platform
 
-- **Major git-safety pass** — clarified TOCTOU ancestry guard, atomic sync-lock acquire with PID-verified stale override, `.git/index.lock` force-removal gated by 5-min age, `GIT_DIR`/`GIT_WORK_TREE`/`GIT_INDEX_FILE` stripped from env overlays, rebase/cherry-pick/revert state detected and aborted in recovery, working tree stashed before `reset --hard` in self-heal/rollback, worktree create guarded against unborn branches, and user hooks + `commit.gpgsign` honored on auto-commits.
-- **Atomic `.gsd/` state writes** — file-locks now actually lock and throw on contention; appends are lock-wrapped to prevent interleaved writes.
-- **Compaction correctness (#4665)** — fixed chunker/truncation mismatch and silent chunk-drops that produced degenerate or empty summaries.
-- **Write-gate (#4950)** — fail-closed depth confirmation, EXDEV-safe snapshot rename, opt-out persistence default, off-by-one max-attempts fix, exception capture in `gate.execute`, and audit/DB rows for unknown gate ids.
-- **Auto state machine** — deterministic policy errors classified non-retriable (#4973), depth-verification bypass for non-interactive sessions, baseline restored between units (#4961), `restoreToolBaseline` gated by `isAutoMode` (#4966).
-- **Slice + crash recovery** — slice orchestrator state persists across crashes; ancestry-guarded force-reset, detached-HEAD refusal, and stash-by-ref recovery.
-- **Empty-turn recovery** — Claude Code CLI tool-block shape canonicalized so empty-turn recovery matches real provider output.
+- **Global MCP config** — `mcp-client` reads `~/.gsd/mcp.json` for user-level MCP server config.
+- **`ask_user_questions` over MCP** — host elicitation tried before remote channel; multi-select array shape preserved; explicit cancellation handled; remote answers normalized into `structuredContent`.
+- **Model routing overhaul** — cross-provider tier resolution, provider-agnostic profile-tier defaults, disabled-provider routing denylist, resolved tier model IDs normalized, and `findModelForTier` with behavioral tests.
+- **Ollama** — configurable probe/request timeouts via env vars (clamped); cloud / long-variant context windows reported correctly.
+- **Windows fixes** — home directory resolved correctly (#5015), `Path` env lookup repaired, Windows-safe env CLI shims, DEP0190 avoided in Claude CLI binary probes, tool-bootstrap skipped when tools are on PATH.
+- **Anthropic prompt-cache preserved (#5019)** — `pi-coding-agent` and `gsd` no longer thrash the cache on dispatch.
 
-See the full [Changelog](./CHANGELOG.md) for details on every release.
+### Git, GitHub Sync & Reliability
+
+- **Integration-branch self-merge guard (#5024)** — milestone refuses to self-merge when the integration branch equals the milestone branch; self-merge ref guard normalized.
+- **Slice-cadence safety** — integration branch used for slice cadence, dirty worktree state preserved on merge, checked-out slice worktrees advance safely, slice PRs deferred until completion, slice-PR sync stays retryable on failure.
+- **Milestone-ID reservation** — DB rows included in reservation; ghost IDs reused in `nextMilestoneId` to close gaps; `ensurePreconditions` guarded against phantom IDs (#4996); orphan milestone-dir doctor check (#4996); milestone-dir creation deferred until first artifact write.
+- **Auto-commit hygiene** — task commits scoped to reported files, generated commit subjects sanitized, user hooks run on automated commits, milestone-tagged commits bound when `.gsd/` is gitignored (#5033), startup blocked on `git index.lock`.
+- **GitHub sync** — issues no longer closed before delivery, failed task closure / slice PR sync stay retryable, config cache scoped by project, safe git environment used.
+
+### Safety, Recovery & Hardening
+
+- **Policy-block pause through dispatch errors** — pause state is preserved when dispatch errors out mid-policy-block.
+- **Skip-validation persistence** — skip-validation state persists and gate rows are cleared on recover.
+- **Cancelled-gate hard block** — redirected to `ask_user_questions`; false plain-text claim dropped from the message.
+- **Write-gate basePath required** — `process.cwd()` defaults removed; basePath threaded through pre-existing tests.
+- **Atomic metrics writes** — parallel-mode `metrics.json` writes merge atomically; ledger cache invalidated after prune; `saveLedger` aborts when lock not acquired; stale-lock detection adds PID stamp + async yield.
+- **Auto-worktree teardown** — `activeWorkspace` guaranteed cleared on teardown failure; teardown try/finally broadened to cover `chdir`; cleanup steps mirrored on the abort path; warning emitted on resume when persisted worktree is missing.
+- **Empty-turn nudge** — no longer auto-replies to user questions; deferred on mid-line approval prompts.
+- **Refuses project writes from `$HOME`** — and surfaces real SQL errors from `capture_thought` instead of swallowing them.
+
+### VS Code & TUI
+
+- **Checkpoint tree view** — registered in the VS Code extension; checkpoint file existence restored; RPC file-mutation events tracked; agent diff scoped to tracked files.
+- **TUI image paste** — pasted images preserved on regular submit.
+- **Bundled `/gsd` slash command protected** — core handler refuses to overwrite the bundled command.
+
+See the full [Changelog](./CHANGELOG.md) for the complete v2.79 entry and prior releases.
+
+<details>
+<summary>v2.78 highlights</summary>
+
+- **Slice-cadence worktree collapse (#4765)** — `git.collapse_cadence: "milestone" | "slice"` shrinks the orphan window per-slice; pair with `git.milestone_resquash: true` to collapse to one milestone commit
+- **Worktree telemetry (#4764)** — journal events + `summarizeWorktreeTelemetry`; `/gsd forensics` worktree section with `worktree-orphan` and `worktree-unmerged-exit` anomalies
+- **Worktree-aware canonical milestone root (#4761)** — `resolveCanonicalMilestoneRoot` routes validators through the live worktree
+- **Bootstrap orphan audit (#4762)** — in-progress milestones with commits ahead of main are no longer skipped
+- **Unified component system** — skills, agents, pipelines, and marketplace as one component model wired through runtime, dispatch, and telemetry
+- **UnitContextManifest v2 (#4924, #4934)** — typed manifest with declarative tools-policy and typed computed artifacts; CI-guarded
+- **Composer migration phase 3 (#4782)** — `complete-slice`, `research-milestone`, `run-uat`, `reassess-roadmap` build context through the manifest composer
+- **Milestone scope classifier + pipeline variants (#4781)** — auto picks a pipeline variant from milestone shape
+- **Per-unit-type skill manifest resolver (#4779)** — skills wire into specific unit types instead of being globally on
+- **Single-writer-v3 control plane** — durable-state writer gaps closed
+- **Extensions framework** — `gsd extensions install / update / uninstall / list / info / validate`; topological load order; cmux↔gsd decoupling via `cmux-events`; extracted `@gsd-extensions/google-search`
+- **GPT-5.5 Codex support** + `xhigh` thinking level; auth mode in `/model`; permission granularity picker; headless auto default → `bypassPermissions` (#4657)
+- **Major git-safety pass** — TOCTOU ancestry guard, atomic sync-lock with PID-verified stale override, `.git/index.lock` 5-min gate, env overlay strip, rebase/cherry-pick/revert detection, working-tree stash before `reset --hard`, unborn-branch worktree guard, user hooks + `commit.gpgsign` on auto-commits
+- **Atomic `.gsd/` state writes**; **compaction correctness fix (#4665)**; **write-gate hardening (#4950)**; **auto state-machine** non-retriable policy errors (#4973), baseline restoration (#4961, #4966); slice + crash recovery; empty-turn recovery shape canonicalized
+
+</details>
 
 <details>
 <summary>v2.77 highlights</summary>
@@ -320,25 +361,27 @@ The database is authoritative for milestones, slices, tasks, requirements, decis
 
 2. **Context pre-loading** — The dispatch prompt includes inlined task plans, slice plans, prior task summaries, dependency summaries, roadmap excerpts, and decisions register. The LLM starts with everything it needs instead of spending tool calls reading files.
 
-3. **Git isolation** — When `git.isolation` is set to `worktree` or `branch`, each milestone runs on its own `milestone/<MID>` branch (in a worktree or in-place). All slice work commits sequentially — no branch switching, no merge conflicts. When the milestone completes, it's squash-merged to main as one clean commit. The default is `none` (work on the current branch), configurable via preferences. If `worktree` is configured in a repo with no committed `HEAD`, GSD temporarily behaves as `none` until the first commit exists because git worktrees need a committed start point.
+3. **Context Mode** — Context Mode is enabled by default and gives every auto-mode unit guidance for preserving context. Agents are steered toward `gsd_exec` for noisy scans, builds, tests, and diagnostics; full stdout/stderr is saved under `.gsd/exec/` while only a short digest enters the conversation. `gsd_exec_search` lets agents reuse prior runs instead of repeating expensive checks, and `gsd_resume` reads `.gsd/last-snapshot.md` after compaction or resume. Opt out with `context_mode.enabled: false`; tune sandbox timeout/output caps with `context_mode.exec_timeout_ms`, `context_mode.exec_stdout_cap_bytes`, and `context_mode.exec_digest_chars`.
+
+4. **Git isolation** — When `git.isolation` is set to `worktree` or `branch`, each milestone runs on its own `milestone/<MID>` branch (in a worktree or in-place). All slice work commits sequentially — no branch switching, no merge conflicts. When the milestone completes, it's squash-merged to main as one clean commit. The default is `none` (work on the current branch), configurable via preferences. If `worktree` is configured in a repo with no committed `HEAD`, GSD temporarily behaves as `none` until the first commit exists because git worktrees need a committed start point.
 
-4. **Crash recovery** — Auto mode persists worker state, unit-dispatch state, and paused-session metadata in the project-root SQLite database. If the session dies, the next `/gsd auto` reconstructs the interrupted unit from DB-backed runtime state, reads the surviving session file, synthesizes a recovery briefing from every tool call that made it to disk, and resumes with full context. Parallel orchestrator IPC still lives under `.gsd/parallel/`, so multi-worker sessions survive crashes too. In headless mode, crashes trigger automatic restart with exponential backoff (default 3 attempts).
+5. **Crash recovery** — Auto mode persists worker state, unit-dispatch state, and paused-session metadata in the project-root SQLite database. If the session dies, the next `/gsd auto` reconstructs the interrupted unit from DB-backed runtime state, reads the surviving session file, synthesizes a recovery briefing from every tool call that made it to disk, and resumes with full context. Parallel orchestrator IPC still lives under `.gsd/parallel/`, so multi-worker sessions survive crashes too. In headless mode, crashes trigger automatic restart with exponential backoff (default 3 attempts).
 
-5. **Provider error recovery** — Transient provider errors (rate limits, 500/503 server errors, overloaded) auto-resume after a delay. Permanent errors (auth, billing) pause for manual review. The model fallback chain retries transient network errors before switching models.
+6. **Provider error recovery** — Transient provider errors (rate limits, 500/503 server errors, overloaded) auto-resume after a delay. Permanent errors (auth, billing) pause for manual review. The model fallback chain retries transient network errors before switching models.
 
-6. **Stuck and artifact detection** — A sliding-window detector identifies repeated dispatch patterns (including multi-unit cycles). Missing expected artifacts use a separate bounded path: GSD retries artifact verification up to 3 times with failure context, then pauses auto mode with the missing artifact error instead of looping indefinitely.
+7. **Stuck and artifact detection** — A sliding-window detector identifies repeated dispatch patterns (including multi-unit cycles). Missing expected artifacts use a separate bounded path: GSD retries artifact verification up to 3 times with failure context, then pauses auto mode with the missing artifact error instead of looping indefinitely.
 
-7. **Timeout supervision** — Soft timeout warns the LLM to wrap up. Idle watchdog detects stalls. Hard timeout pauses auto mode. Recovery steering nudges the LLM to finish durable output before giving up.
+8. **Timeout supervision** — Soft timeout warns the LLM to wrap up. Idle watchdog detects stalls. Hard timeout pauses auto mode. Recovery steering nudges the LLM to finish durable output before giving up.
 
-8. **Cost tracking** — Every unit's token usage and cost is captured, broken down by phase, slice, and model. The dashboard shows running totals and projections. Budget ceilings can pause auto mode before overspending.
+9. **Cost tracking** — Every unit's token usage and cost is captured, broken down by phase, slice, and model. The dashboard shows running totals and projections. Budget ceilings can pause auto mode before overspending.
 
-9. **Adaptive replanning** — After each slice completes, the roadmap is reassessed. If the work revealed new information that changes the plan, slices are reordered, added, or removed before continuing.
+10. **Adaptive replanning** — After each slice completes, the roadmap is reassessed. If the work revealed new information that changes the plan, slices are reordered, added, or removed before continuing.
 
-10. **Verification enforcement** — Configure shell commands (`npm run lint`, `npm run test`, etc.) that run automatically after task execution. Failures trigger auto-fix retries before advancing. Auto-discovered checks from `package.json` run in advisory mode — they log warnings but don't block on pre-existing errors. Configurable via `verification_commands`, `verification_auto_fix`, and `verification_max_retries` preferences.
+11. **Verification enforcement** — Configure shell commands (`npm run lint`, `npm run test`, etc.) that run automatically after task execution. Failures trigger auto-fix retries before advancing. Auto-discovered checks from `package.json` run in advisory mode — they log warnings but don't block on pre-existing errors. Configurable via `verification_commands`, `verification_auto_fix`, and `verification_max_retries` preferences.
 
-11. **Milestone validation** — After all slices complete, a `validate-milestone` gate compares roadmap success criteria against actual results before sealing the milestone.
+12. **Milestone validation** — After all slices complete, a `validate-milestone` gate compares roadmap success criteria against actual results before sealing the milestone.
 
-12. **Escape hatch** — Press Escape to pause. The conversation is preserved. Interact with the agent, inspect what happened, or just `/gsd auto` to resume from disk state.
+13. **Escape hatch** — Press Escape to pause. The conversation is preserved. Interact with the agent, inspect what happened, or just `/gsd auto` to resume from disk state.
 
 ### `/gsd` and `/gsd next` — Step Mode
 
@@ -616,6 +659,10 @@ auto_report: true
 | `unique_milestone_ids`            | Uses unique milestone names to avoid clashes when working in teams of people                          |
 | `git.isolation`                   | `none` (default), `worktree`, or `branch` — enable worktree or branch isolation for milestone work. `worktree` requires a committed `HEAD`; zero-commit repos temporarily run as `none`    |
 | `git.manage_gitignore`            | Set `false` to prevent GSD from modifying `.gitignore`                                                |
+| `context_mode.enabled`            | Context Mode is default-on; set `false` to disable `gsd_exec`, exec history guidance, and resume snapshots |
+| `context_mode.exec_timeout_ms`    | Timeout for sandboxed `gsd_exec` runs (default: 30000)                                                |
+| `context_mode.exec_stdout_cap_bytes` | Persisted stdout cap for `gsd_exec` output (default: 1048576)                                      |
+| `context_mode.exec_digest_chars`  | Trailing stdout characters returned to the agent context (default: 300)                              |
 | `verification_commands`           | Array of shell commands to run after task execution (e.g., `["npm run lint", "npm run test"]`)        |
 | `verification_auto_fix`           | Auto-retry on verification failures (default: true)                                                   |
 | `verification_max_retries`        | Max retries for verification failures (default: 2)                                                    |

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-36cc9805e706289c
+97e376d99205971f

package/dist/resources/extensions/gsd/auto-prompts.js

@@ -10,6 +10,7 @@ import { hasVerdict, getUatType } from "./verdict-parser.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
 import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, resolveTaskFiles, resolveTaskFile, relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath, resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile, } from "./paths.js";
 import { resolveSkillDiscoveryMode, resolveInlineLevel, loadEffectiveGSDPreferences, resolveAllSkillReferences } from "./preferences.js";
+import { isContextModeEnabled } from "./preferences-types.js";
 import { parseRoadmap } from "./parsers-legacy.js";
 import { getLoadedSkills } from "@gsd/pi-coding-agent";
 import { join, basename } from "node:path";
@@ -19,7 +20,7 @@ import { getPendingGatesForTurn } from "./gsd-db.js";
 import { assertGateCoverage, getGatesForTurn, } from "./gate-registry.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
 import { readPhaseAnchor, formatAnchorForPrompt } from "./phase-anchor.js";
-import { composeInlinedContext } from "./unit-context-composer.js";
+import { composeContextModeInstructions, composeInlinedContext } from "./unit-context-composer.js";
 import { logWarning } from "./workflow-logger.js";
 import { inlineGraphSubgraph } from "./graph-context.js";
 import { buildExtractionStepsBlock } from "./commands-extract-learnings.js";
@@ -71,6 +72,21 @@ function capPreamble(preamble) {
         return preamble;
     return truncateAtSectionBoundary(preamble, budget).content;
 }
+function renderContextModeForPrompt(unitType, base, renderMode = "standalone") {
+    const effectivePrefs = loadEffectiveGSDPreferences(base)?.preferences;
+    return composeContextModeInstructions(unitType, {
+        enabled: isContextModeEnabled(effectivePrefs),
+        renderMode,
+    });
+}
+function prependContextModeToBlock(unitType, base, block, renderMode = "standalone") {
+    const contextMode = renderContextModeForPrompt(unitType, base, renderMode);
+    if (!contextMode)
+        return block;
+    if (!block.trim())
+        return contextMode;
+    return `${contextMode}\n\n${block}`;
+}
 // ─── Executor Constraints ─────────────────────────────────────────────────────
 /**
  * Format executor context constraints for injection into the plan-slice prompt.
@@ -1119,6 +1135,7 @@ export async function checkNeedsRunUat(base, mid, state, prefs) {
  */
 export async function buildDiscussMilestonePrompt(mid, midTitle, base, structuredQuestionsAvailable = "false") {
     const discussTemplates = inlineTemplate("context", "Context");
+    const contextModeInstructions = renderContextModeForPrompt("discuss-milestone", base);
     const basePrompt = loadPrompt("guided-discuss-milestone", {
         workingDirectory: base,
         milestoneId: mid,
@@ -1128,13 +1145,14 @@ export async function buildDiscussMilestonePrompt(mid, midTitle, base, structure
         commitInstruction: "Do not commit planning artifacts — .gsd/ is managed externally.",
         fastPathInstruction: "",
     });
+    const promptWithContextMode = prependContextModeToBlock("discuss-milestone", base, basePrompt);
     // If a CONTEXT-DRAFT.md exists, append it as seed material
     const draftPath = resolveMilestoneFile(base, mid, "CONTEXT-DRAFT");
     const draftContent = draftPath ? await loadFile(draftPath) : null;
     if (draftContent) {
-        return `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\nThe following draft was captured from a prior multi-milestone discussion. Use it as seed material — the user has already provided this context. Start with a brief reflection on what the draft covers, then probe for any gaps or open questions before writing the full CONTEXT.md.\n\n${draftContent}`;
+        return `${promptWithContextMode}\n\n## Prior Discussion (Draft Seed)\n\nThe following draft was captured from a prior multi-milestone discussion. Use it as seed material — the user has already provided this context. Start with a brief reflection on what the draft covers, then probe for any gaps or open questions before writing the full CONTEXT.md.\n\n${draftContent}`;
     }
-    return basePrompt;
+    return contextModeInstructions ? promptWithContextMode : basePrompt;
 }
 /**
  * Build a prompt for the workflow-preferences unit type (deep mode).
@@ -1143,10 +1161,10 @@ export async function buildDiscussMilestonePrompt(mid, midTitle, base, structure
  * in deep-mode bootstrap before discuss-project.
  */
 export async function buildWorkflowPreferencesPrompt(base, structuredQuestionsAvailable = "false") {
-    return loadPrompt("guided-workflow-preferences", {
+    return prependContextModeToBlock("workflow-preferences", base, loadPrompt("guided-workflow-preferences", {
         workingDirectory: base,
         structuredQuestionsAvailable,
-    });
+    }));
 }
 /**
  * Build a prompt for the research-project (parallel) unit type (deep mode).
@@ -1156,10 +1174,10 @@ export async function buildWorkflowPreferencesPrompt(base, structuredQuestionsAv
  * are missing. Skipped entirely if user picked "skip".
  */
 export async function buildResearchProjectPrompt(base, structuredQuestionsAvailable = "false") {
-    return loadPrompt("guided-research-project", {
+    return prependContextModeToBlock("research-project", base, loadPrompt("guided-research-project", {
         workingDirectory: base,
         structuredQuestionsAvailable,
-    });
+    }));
 }
 /**
  * Build a prompt for the research-decision unit type (deep mode).
@@ -1168,10 +1186,10 @@ export async function buildResearchProjectPrompt(base, structuredQuestionsAvaila
  * and before research-project-parallel.
  */
 export async function buildResearchDecisionPrompt(base, structuredQuestionsAvailable = "false") {
-    return loadPrompt("guided-research-decision", {
+    return prependContextModeToBlock("research-decision", base, loadPrompt("guided-research-decision", {
         workingDirectory: base,
         structuredQuestionsAvailable,
-    });
+    }));
 }
 /**
  * Build a prompt for the discuss-project unit type (deep mode).
@@ -1181,12 +1199,12 @@ export async function buildResearchDecisionPrompt(base, structuredQuestionsAvail
  */
 export async function buildDiscussProjectPrompt(base, structuredQuestionsAvailable = "false") {
     const inlinedTemplates = inlineTemplate("project", "Project");
-    return loadPrompt("guided-discuss-project", {
+    return prependContextModeToBlock("discuss-project", base, loadPrompt("guided-discuss-project", {
         workingDirectory: base,
         inlinedTemplates,
         structuredQuestionsAvailable,
         commitInstruction: "Do not commit planning artifacts — .gsd/ is managed externally.",
-    });
+    }));
 }
 /**
  * Build a prompt for the discuss-requirements unit type (deep mode).
@@ -1196,12 +1214,12 @@ export async function buildDiscussProjectPrompt(base, structuredQuestionsAvailab
  */
 export async function buildDiscussRequirementsPrompt(base, structuredQuestionsAvailable = "false") {
     const inlinedTemplates = inlineTemplate("requirements", "Requirements");
-    return loadPrompt("guided-discuss-requirements", {
+    return prependContextModeToBlock("discuss-requirements", base, loadPrompt("guided-discuss-requirements", {
         workingDirectory: base,
         inlinedTemplates,
         structuredQuestionsAvailable,
         commitInstruction: "Do not commit planning artifacts — .gsd/ is managed externally.",
-    });
+    }));
 }
 export async function buildResearchMilestonePrompt(mid, midTitle, base) {
     // #4782 phase 3: research-milestone migrated through the composer.
@@ -1254,7 +1272,7 @@ export async function buildResearchMilestonePrompt(mid, midTitle, base) {
         if (knowledgeInlineRM)
             parts.push(knowledgeInlineRM);
     }
-    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${parts.join("\n\n---\n\n")}`);
+    const inlinedContext = prependContextModeToBlock("research-milestone", base, capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${parts.join("\n\n---\n\n")}`));
     const outputRelPath = relMilestoneFile(base, mid, "RESEARCH");
     return loadPrompt("research-milestone", {
         workingDirectory: base,
@@ -1324,7 +1342,7 @@ export async function buildPlanMilestonePrompt(mid, midTitle, base, level) {
         inlined.push(inlineTemplate("plan", "Slice Plan"));
         inlined.push(inlineTemplate("task-plan", "Task Plan"));
     }
-    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
+    const inlinedContext = prependContextModeToBlock("plan-milestone", base, capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`));
     const outputRelPath = relMilestoneFile(base, mid, "ROADMAP");
     const researchOutputPath = join(base, relMilestoneFile(base, mid, "RESEARCH"));
     const secretsOutputPath = join(base, relMilestoneFile(base, mid, "SECRETS"));
@@ -1349,7 +1367,7 @@ export async function buildPlanMilestonePrompt(mid, midTitle, base, level) {
         ...buildSkillDiscoveryVars(),
     });
 }
-export async function buildResearchSlicePrompt(mid, _midTitle, sid, sTitle, base) {
+export async function buildResearchSlicePrompt(mid, _midTitle, sid, sTitle, base, options) {
     const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
     const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
     const contextPath = resolveMilestoneFile(base, mid, "CONTEXT");
@@ -1400,7 +1418,7 @@ export async function buildResearchSlicePrompt(mid, _midTitle, sid, sTitle, base
     const overridesInline = formatOverridesSection(activeOverrides);
     if (overridesInline)
         inlined.unshift(overridesInline);
-    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
+    const inlinedContext = prependContextModeToBlock("research-slice", base, capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`), options?.contextModeRenderMode);
     const outputRelPath = relSliceFile(base, mid, sid, "RESEARCH");
     return loadPrompt("research-slice", {
         workingDirectory: base,
@@ -1483,7 +1501,7 @@ async function renderSlicePrompt(options) {
     const overridesInline = formatOverridesSection(await loadActiveOverrides(base));
     if (overridesInline)
         inlined.unshift(overridesInline);
-    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
+    const inlinedContext = prependContextModeToBlock(promptTemplate, base, capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`), options.contextModeRenderMode);
     const executorContextConstraints = formatExecutorConstraints(sessionContextWindow, modelRegistry, sessionProvider);
     const outputRelPath = relSliceFile(base, mid, sid, "PLAN");
     const commitInstruction = "Do not commit — .gsd/ planning docs are managed externally and not tracked in git.";
@@ -1686,6 +1704,7 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
     const etPending = getPendingGatesForTurn(mid, sid, "execute-task", tid);
     assertGateCoverage(etPending, "execute-task", { requireAll: false });
     const gatesToClose = renderGatesToCloseBlock(getGatesForTurn("execute-task"), { pending: new Set(etPending.map((g) => g.gate_id)), allowOmit: true });
+    phaseAnchorSection = prependContextModeToBlock("execute-task", base, phaseAnchorSection, opts.contextModeRenderMode);
     return loadPrompt("execute-task", {
         overridesSection,
         runtimeContext,
@@ -1713,6 +1732,7 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
             taskTitle: tTitle,
             taskPlanContent,
             extraContext: [taskPlanInline, slicePlanExcerpt, finalCarryForward, resumeSection],
+            unitType: "execute-task",
         }),
     });
 }
@@ -1803,7 +1823,7 @@ export async function buildCompleteSlicePrompt(mid, midTitle, sid, sTitle, base,
     const finalBody = completeOverridesInline
         ? `${completeOverridesInline}\n\n---\n\n${body}`
         : body;
-    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${finalBody}`);
+    const inlinedContext = prependContextModeToBlock("complete-slice", base, capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${finalBody}`));
     const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
     const sliceRel = relSlicePath(base, mid, sid);
     const sliceSummaryPath = join(base, `${sliceRel}/${sid}-SUMMARY.md`);
@@ -1894,7 +1914,7 @@ export async function buildCompleteMilestonePrompt(mid, midTitle, base, level) {
     if (contextInline)
         inlined.push(contextInline);
     inlined.push(inlineTemplate("milestone-summary", "Milestone Summary"));
-    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
+    const inlinedContext = prependContextModeToBlock("complete-milestone", base, capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`));
     const milestoneSummaryPath = join(base, `${relMilestonePath(base, mid)}/${mid}-SUMMARY.md`);
     const learningsRelPath = join(relMilestonePath(base, mid), `${mid}-LEARNINGS.md`);
     const learningsAbsPath = join(base, learningsRelPath);
@@ -2034,7 +2054,7 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
     const contextInline = await inlineFileOptional(contextPath, contextRel, "Milestone Context");
     if (contextInline)
         inlined.push(contextInline);
-    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
+    const inlinedContext = prependContextModeToBlock("validate-milestone", base, capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`));
     const validationOutputPath = join(base, `${relMilestonePath(base, mid)}/${mid}-VALIDATION.md`);
     const roadmapOutputPath = `${relMilestonePath(base, mid)}/${mid}-ROADMAP.md`;
     // Every milestone validation turn owns MV01–MV04 unconditionally: the
@@ -2104,7 +2124,7 @@ export async function buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base) {
     const replanOverridesInline = formatOverridesSection(replanActiveOverrides);
     if (replanOverridesInline)
         inlined.unshift(replanOverridesInline);
-    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
+    const inlinedContext = prependContextModeToBlock("replan-slice", base, capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`));
     const replanPath = join(base, `${relSlicePath(base, mid, sid)}/${sid}-REPLAN.md`);
     // Build capture context for replan prompt (captures that triggered this replan)
     let captureContext = "(none)";
@@ -2171,7 +2191,7 @@ export async function buildRunUatPrompt(mid, sliceId, uatPath, uatContent, base)
         }
     };
     const composed = await composeInlinedContext("run-uat", resolveArtifact);
-    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${composed}`);
+    const inlinedContext = prependContextModeToBlock("run-uat", base, capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${composed}`));
     const uatResultPath = join(base, relSliceFile(base, mid, sliceId, "ASSESSMENT"));
     const uatType = getUatType(uatContent);
     return loadPrompt("run-uat", {
@@ -2242,7 +2262,7 @@ export async function buildReassessRoadmapPrompt(mid, midTitle, completedSliceId
     const knowledgeInlineRA = await inlineKnowledgeBudgeted(base, extractKeywords(midTitle));
     if (knowledgeInlineRA)
         parts.push(knowledgeInlineRA);
-    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${parts.join("\n\n---\n\n")}`);
+    const inlinedContext = prependContextModeToBlock("reassess-roadmap", base, capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${parts.join("\n\n---\n\n")}`));
     const assessmentPath = join(base, relSliceFile(base, mid, completedSliceId, "ASSESSMENT"));
     // Build deferred captures context for reassess prompt
     let deferredCaptures = "(none)";
@@ -2313,6 +2333,7 @@ export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, rea
             sessionContextWindow: opts?.sessionContextWindow,
             modelRegistry: opts?.modelRegistry,
             sessionProvider: opts?.sessionProvider,
+            contextModeRenderMode: "nested",
         });
         const modelSuffix = subagentModel ? ` with model: "${subagentModel}"` : "";
         subagentSections.push([
@@ -2332,7 +2353,7 @@ export async function buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, rea
         milestoneTitle: midTitle,
         sliceId: sid,
         sliceTitle: sTitle,
-        graphContext,
+        graphContext: prependContextModeToBlock("reactive-execute", base, graphContext),
         readyTaskCount: String(readyTaskIds.length),
         readyTaskList: readyTaskListLines.join("\n"),
         subagentPrompts: subagentSections.join("\n\n---\n\n"),
@@ -2382,7 +2403,7 @@ export async function buildParallelResearchSlicesPrompt(mid, midTitle, slices, b
     const subagentSections = [];
     const modelSuffix = subagentModel ? ` with model: "${subagentModel}"` : "";
     for (const slice of slices) {
-        const slicePrompt = await buildResearchSlicePrompt(mid, midTitle, slice.id, slice.title, basePath);
+        const slicePrompt = await buildResearchSlicePrompt(mid, midTitle, slice.id, slice.title, basePath, { contextModeRenderMode: "nested" });
         subagentSections.push([
             `### ${slice.id}: ${slice.title}`,
             "",
@@ -2426,6 +2447,8 @@ export async function buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, base,
     for (const def of gateDefs) {
         gateListLines.push(`- **${def.id}**: ${def.question}`);
         const subPrompt = [
+            renderContextModeForPrompt("gate-evaluate", base, "nested"),
+            "",
             `You are evaluating quality gate **${def.id}** for slice ${sid} (${sTitle}).`,
             "",
             `**Working directory:** \`${normalizedBase}\`. All file reads, writes, and shell commands MUST operate relative to this directory. Do NOT \`cd\` to any other directory.`,
@@ -2466,7 +2489,7 @@ export async function buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, base,
         milestoneTitle: midTitle,
         sliceId: sid,
         sliceTitle: sTitle,
-        slicePlanContent: planContent,
+        slicePlanContent: prependContextModeToBlock("gate-evaluate", base, planContent),
         gateCount: String(pending.length),
         gateList: gateListLines.join("\n"),
         subagentPrompts: subagentSections.join("\n\n---\n\n"),
@@ -2536,7 +2559,7 @@ export async function buildRewriteDocsPrompt(mid, midTitle, activeSlice, base, o
         `**During:** ${o.appliedAt}`,
     ].join("\n")).join("\n\n");
     const documentList = docList.length > 0 ? docList.join("\n") : "- No active plan documents found.";
-    return loadPrompt("rewrite-docs", {
+    return prependContextModeToBlock("rewrite-docs", base, loadPrompt("rewrite-docs", {
         workingDirectory: base,
         milestoneId: mid,
         milestoneTitle: midTitle,
@@ -2545,5 +2568,5 @@ export async function buildRewriteDocsPrompt(mid, midTitle, activeSlice, base, o
         overrideContent,
         documentList,
         overridesPath: relGsdRootFile("OVERRIDES"),
-    });
+    }));
 }

package/dist/resources/extensions/gsd/auto-recovery.js

@@ -257,7 +257,7 @@ function scanGsdTaggedCommits(basePath, milestoneId, gitArgs) {
             if (!commitMessageHasGsdTrailer(message))
                 continue;
             const commitFiles = getChangedFilesForCommit(basePath, hash);
-            if (!commitMatchesMilestone(message, milestoneId, commitFiles))
+            if (!commitMatchesMilestone(basePath, message, milestoneId, commitFiles))
                 continue;
             matched = true;
             for (const file of commitFiles) {
@@ -278,22 +278,37 @@ function getChangedFilesForCommit(basePath, hash) {
 function commitMessageHasGsdTrailer(message) {
     return /^GSD-(?:Task|Unit):\s*\S+/m.test(message);
 }
-function commitMatchesMilestone(message, milestoneId, files) {
+function commitMatchesMilestone(basePath, message, milestoneId, files) {
     if (commitTrailerStartsWithMilestone(message, milestoneId))
         return true;
     // Meaningful execute-task commits currently store task scope as Sxx/Tyy
     // rather than Mxx/Sxx/Tyy. Bind those commits back to the milestone when
     // either the commit touched this milestone's artifacts, or — for projects
     // where .gsd/ is gitignored/external (#5033) — the message explicitly
-    // names the milestone.
+    // names the milestone or local GSD state proves the task belongs here.
     if (/^GSD-Task:\s*S[^/\s]+\/T\S+/m.test(message)) {
         if (files.some((file) => isMilestoneArtifactPath(file, milestoneId)))
             return true;
         if (commitMessageMentionsMilestone(message, milestoneId))
             return true;
+        if (commitTaskTrailerBelongsToMilestone(basePath, message, milestoneId))
+            return true;
     }
     return false;
 }
+function commitTaskTrailerBelongsToMilestone(basePath, message, milestoneId) {
+    const match = message.match(/^GSD-Task:\s*(S[^/\s]+)\/(T[^\s]+)/m);
+    if (!match)
+        return false;
+    const [, sliceId, taskId] = match;
+    if (getTask(milestoneId, sliceId, taskId))
+        return true;
+    const tasksDir = resolveTasksDir(basePath, milestoneId, sliceId);
+    if (!tasksDir)
+        return false;
+    return existsSync(join(tasksDir, `${taskId}-PLAN.md`))
+        || existsSync(join(tasksDir, `${taskId}-SUMMARY.md`));
+}
 function commitMessageMentionsMilestone(message, milestoneId) {
     if (!MILESTONE_ID_RE.test(milestoneId))
         return false;

package/dist/resources/extensions/gsd/bootstrap/exec-tools.js

@@ -1,7 +1,7 @@
 // GSD2 — Exec (context-mode) tool registration.
 //
-// Exposes the `gsd_exec` tool over MCP. Opt-in: disabled unless
-// `context_mode.enabled: true` is set in preferences.
+// Exposes the Context Mode runtime tools in-process. Default-on; opt out with
+// `context_mode.enabled: false` in preferences.
 import { Type } from "@sinclair/typebox";
 export function registerExecTools(pi) {
     pi.registerTool({