gsd-pi 2.67.0-dev.46f9884 → 2.67.0-dev.4fb8afe

package/README.md

@@ -27,56 +27,66 @@ One command. Walk away. Come back to a built project with clean git history.
 
 ---
 
-## What's New in v2.63.0
+## What's New in v2.67
 
-### MCP Server & Integrations
+### Context Engineering
+
+- **Tiered Context Injection (M005)** — relevance-scoped context with 65%+ token reduction. Decision scope cascade derives context from slice metadata instead of blanket injection.
+- **Resilient transient error recovery** — defers to Core RetryHandler and fixes cmdCtx race conditions for more reliable auto-mode sessions.
 
-- **MCP server** — 6 read-only project state tools for external integrations, auto-wrapup guard, and question dedup.
-- **Ollama extension** — first-class local LLM support via Ollama, with dynamic routing enabled by default.
-- **Discord bot & daemon** — dedicated daemon package, Discord bot with 6 discord.js shard event listeners, and headless text mode with tool calls.
+### Provider & Model Improvements
 
-### Intelligent Model Routing
+- **Anthropic subscription routing** — users with Anthropic subscriptions are automatically routed through Claude Code CLI provider with proper display names across all UI surfaces.
+- **Claude Code provider hardening** — native Windows claude lookup, fallback guards, and `out of extra usage` error matching.
+- **XML parameter recovery** — pi-ai recovers XML parameters trapped in JSON strings from providers.
 
-- **Capability-aware model routing (ADR-004)** — capability scoring, `before_model_select` hook, and task metadata extraction replace pattern-based model selection.
-- **Stop/backtrack capture classifications** — context optimization with model routing and masking.
+### Safety & Data Integrity
 
-### VS Code & TUI
+- **LLM safety harness** — auto-mode damage control prevents the LLM from running destructive operations or querying `gsd.db` directly via bash.
+- **5-wave state machine hardening** — critical data integrity fixes across atomic writes, randomized tmp paths, event log reconciliation, session recovery, and consistency enforcement. 86+ regression tests added.
+- **Discussion gate enforcement** — mechanical enforcement for discussion question gates with fail-closed behavior.
+- **Enhanced verification** — pre-execution plan verification checks, post-execution cross-task consistency checks, blocking behavior and strict mode.
 
-- **VS Code sidebar redesign** — SCM provider, checkpoints, diagnostics panel, activity feed, workflow controls, session forking, and enhanced code lens.
-- **`/gsd parallel watch`** — native TUI overlay for real-time worker monitoring.
-- **Real-time TUI monitor dashboard** — self-healing dashboard with colorized headless verbose output.
+### Parallel Execution & Dispatch
 
-### Agent & Auto-Mode
+- **Slice-level parallelism** — dependency-aware parallel dispatch within a milestone, not just across milestones.
+- **Parallel research slices** — research and milestone validation run in parallel.
+- **Worker model override** — configure different models for parallel milestone workers.
 
-- **`/btw` skill** — ephemeral side questions without interrupting the main workflow.
-- **Codebase map** — automatic codebase map injection for fresh agent contexts.
-- **`--resume` flag** — resume previous sessions from the CLI.
-- **Concurrent invocation guard** — prevents overlapping auto-mode runs with parallel worker reliability improvements.
-- **Safety mechanisms on by default** — snapshots and pre-merge checks enabled out of the box.
+### TUI & Notifications
 
-### Infrastructure & Performance
+- **Persistent notification panel** — TUI overlay, widget, and web API for real-time notifications.
+- **Remote questions race** — local TUI races against remote channel (Slack/Discord) instead of remote-only routing.
+- **OS-specific keyboard shortcuts** — shortcut hints now adapt to macOS/Linux/Windows.
+- **`/gsd show-config`** — inspect active configuration at a glance.
 
-- **Topological sort for extensions** — correct load ordering for dependent extensions.
-- **Headless integration hardening** — real-time streaming, verbose output, and observability improvements across v2.54–v2.55.
-- **GLM-5.1 model** — new model support added.
-- **80+ bug fixes** — worktree safety, parallel mode scoping, state corruption, and more.
+### Infrastructure
+
+- **Ollama native provider** — `/api/chat` provider with full option exposure, `apiKey` auth mode, and headless probe.
+- **MCP OAuth** — MCP client supports OAuth auth provider for HTTP transport.
+- **WAL-safe migration backup** — database migrations create WAL-safe backups with stronger regression tests.
+- **Xcode/xcodegen detection** — project detection now supports Xcode bundles and xcodegen.
+- **170+ bug fixes** — state machine resilience, worktree safety, prompt injection, session recovery, and more.
 
 See the full [Changelog](./CHANGELOG.md) for details on every release.
 
 <details>
-<summary>Previous highlights (v2.52 and earlier)</summary>
-
+<summary>Previous highlights (v2.63 and earlier)</summary>
+
+- **MCP server** — 6 read-only project state tools for external integrations, auto-wrapup guard, and question dedup
+- **Ollama extension** — first-class local LLM support via Ollama, with dynamic routing enabled by default
+- **Discord bot & daemon** — dedicated daemon package, Discord bot, and headless text mode with tool calls
+- **Capability-aware model routing (ADR-004)** — capability scoring, `before_model_select` hook, and task metadata extraction
+- **VS Code sidebar redesign** — SCM provider, checkpoints, diagnostics panel, activity feed, workflow controls, session forking
+- **`/gsd parallel watch`** — native TUI overlay for real-time worker monitoring
+- **Codebase map** — automatic codebase map injection for fresh agent contexts
+- **`--resume` flag** — resume previous sessions from the CLI
+- **Concurrent invocation guard** — prevents overlapping auto-mode runs
 - **VS Code integration** — status bar, file decorations, bash terminal, session tree, conversation history, and code lens
-- **Capability-based model selection** — replaced model-ID pattern matching with capability metadata
 - **Skills overhaul** — 30+ skill packs covering major frameworks, databases, and cloud platforms
-- **Quality gates** — 8-question quality gates for planning and completion templates
 - **Single-writer state engine** — disciplined state transitions with machine guards and TOCTOU hardening
-- **`/gsd rethink`** — conversational project reorganization
-- **Complete offline mode** — fully offline with local models
-- **Browser-based web interface** — run GSD from the browser with `gsd --web`
 - **DB-backed planning tools** — atomic SQLite tool calls for state transitions
 - **Declarative workflow engine** — YAML workflows through auto-loop
-- **7 data-loss prevention fixes** — hallucination guard, merge anchor verification, dirty tree detection, and more
 - **Doctor: worktree lifecycle checks** — validates worktree health, detects orphans, consolidates cleanup
 
 </details>
@@ -85,7 +95,7 @@ See the full [Changelog](./CHANGELOG.md) for details on every release.
 
 ## Documentation
 
-Full documentation is available at **[gsd.build](https://gsd.build)** (powered by Mintlify) and in the [`docs/`](./docs/) directory:
+Full documentation is available in the [`docs/`](./docs/) directory:
 
 - **[Getting Started](./docs/getting-started.md)** — install, first run, basic usage
 - **[Auto Mode](./docs/auto-mode.md)** — autonomous execution deep-dive

package/dist/resource-loader.d.ts

@@ -22,5 +22,5 @@ export declare function getNewerManagedResourceVersion(agentDir: string, current
  * Inspectable: `ls ~/.gsd/agent/extensions/`
  */
 export declare function initResources(agentDir: string): void;
-export declare function hasStaleCompiledExtensionSiblings(extensionsDir: string): boolean;
+export declare function hasStaleCompiledExtensionSiblings(extensionsDir: string, sourceDir?: string): boolean;
 export declare function buildResourceLoader(agentDir: string): DefaultResourceLoader;

package/dist/resource-loader.js

@@ -384,11 +384,13 @@ export function initResources(agentDir) {
     mkdirSync(agentDir, { recursive: true });
     const currentVersion = getBundledGsdVersion();
     const manifest = readManagedResourceManifest(agentDir);
+    const extensionsDir = join(agentDir, 'extensions');
     // Always prune root-level extension files that were removed from the bundle.
     // This is cheap (a few existence checks + at most one rmSync) and must run
     // unconditionally so that stale files left by a previous version are cleaned
     // up even when the version/hash match causes the full sync to be skipped.
     pruneRemovedBundledExtensions(manifest, agentDir);
+    pruneStaleSiblingFiles(bundledExtensionsDir, extensionsDir);
     // Ensure ~/.gsd/agent/node_modules symlinks to GSD's node_modules on EVERY
     // launch, not just during resource syncs. A stale/broken symlink makes ALL
     // extensions fail to resolve @gsd/* packages, rendering GSD non-functional.
@@ -402,7 +404,7 @@ export function initResources(agentDir) {
     if (manifest && manifest.gsdVersion === currentVersion) {
         // Version matches — check content fingerprint for same-version staleness.
         const currentHash = computeResourceFingerprint();
-        const hasStaleExtensionFiles = hasStaleCompiledExtensionSiblings(join(agentDir, 'extensions'));
+        const hasStaleExtensionFiles = hasStaleCompiledExtensionSiblings(extensionsDir, bundledExtensionsDir);
         if (manifest.contentHash && manifest.contentHash === currentHash && !hasStaleExtensionFiles) {
             return;
         }
@@ -555,14 +557,27 @@ function migrateSkillsToEcosystemDir(agentDir) {
         }
     }
 }
-export function hasStaleCompiledExtensionSiblings(extensionsDir) {
+export function hasStaleCompiledExtensionSiblings(extensionsDir, sourceDir = bundledExtensionsDir) {
     if (!existsSync(extensionsDir))
         return false;
+    const sourceFiles = existsSync(sourceDir)
+        ? new Set(readdirSync(sourceDir, { withFileTypes: true })
+            .filter((entry) => entry.isFile())
+            .map((entry) => entry.name))
+        : new Set();
     for (const entry of readdirSync(extensionsDir, { withFileTypes: true })) {
-        if (!entry.isFile() || !entry.name.endsWith('.ts'))
+        if (!entry.isFile())
+            continue;
+        if (!entry.name.endsWith('.ts') && !entry.name.endsWith('.js'))
+            continue;
+        const siblingName = entry.name.endsWith('.ts')
+            ? entry.name.replace(/\.ts$/, '.js')
+            : entry.name.replace(/\.js$/, '.ts');
+        if (!existsSync(join(extensionsDir, siblingName)))
+            continue;
+        if (sourceFiles.has(entry.name) && sourceFiles.has(siblingName))
             continue;
-        const jsName = entry.name.replace(/\.ts$/, '.js');
-        if (existsSync(join(extensionsDir, jsName))) {
+        if (sourceFiles.has(entry.name) || sourceFiles.has(siblingName)) {
             return true;
         }
     }

package/dist/resources/GSD-WORKFLOW.md

@@ -18,7 +18,8 @@ Read these files in order and act on what they say:
 3. **`.gsd/milestones/<active>/M###-CONTEXT.md`** — Milestone-level project decisions, reference paths, constraints. Read this before doing implementation work.
 4. If a slice is active and has one, read **`S##-CONTEXT.md`** — Slice-specific decisions and constraints.
 5. If a slice is active, read its **`S##-PLAN.md`** — Which tasks exist? Which are done?
-6. If a task was interrupted, check for **`continue.md`** in the active slice directory — Resume from there.
+6. If `.gsd/CODEBASE.md` exists, skim it for fast structural orientation before broad code exploration.
+7. If a task was interrupted, check for **`continue.md`** in the active slice directory — Resume from there.
 
 Then do the thing `STATE.md` says to do next.
 
@@ -44,6 +45,7 @@ All artifacts live in `.gsd/` at the project root:
 .gsd/
   STATE.md                                  # Dashboard — always read first (derived cache; runtime, gitignored)
   DECISIONS.md                              # Append-only decisions register
+  CODEBASE.md                               # Generated codebase map cache (auto-refreshed by GSD)
   milestones/
     M001/
       M001-ROADMAP.md                       # Milestone plan (checkboxes = state)

package/dist/resources/extensions/claude-code-cli/stream-adapter.js

@@ -9,6 +9,7 @@
 import { EventStream } from "@gsd/pi-ai";
 import { execSync } from "node:child_process";
 import { PartialMessageBuilder, ZERO_USAGE, mapUsage } from "./partial-builder.js";
+import { buildWorkflowMcpServers } from "../gsd/workflow-mcp.js";
 // ---------------------------------------------------------------------------
 // Stream factory
 // ---------------------------------------------------------------------------
@@ -123,6 +124,70 @@ export function makeStreamExhaustedErrorMessage(model, lastTextContent) {
     }
     return message;
 }
+/**
+ * Claude Code executes its own internal tool loop inside the SDK call. The
+ * streamed and final assistant messages should therefore contain only
+ * user-facing content (text/thinking), not replayable tool blocks that GSD
+ * would render again.
+ */
+function isUserFacingClaudeCodeBlock(block) {
+    return block.type === "text" || block.type === "thinking";
+}
+function filterUserFacingClaudeCodeContent(blocks) {
+    return blocks.filter(isUserFacingClaudeCodeBlock);
+}
+function remapClaudeCodeContentIndex(blocks, contentIndex) {
+    let visibleCount = 0;
+    for (let i = 0; i <= contentIndex && i < blocks.length; i++) {
+        if (isUserFacingClaudeCodeBlock(blocks[i]))
+            visibleCount++;
+    }
+    return Math.max(0, visibleCount - 1);
+}
+function sanitizeClaudeCodePartial(partial) {
+    return {
+        ...partial,
+        content: filterUserFacingClaudeCodeContent(partial.content),
+    };
+}
+export function sanitizeClaudeCodeStreamingEvent(event) {
+    switch (event.type) {
+        case "toolcall_start":
+        case "toolcall_delta":
+        case "toolcall_end":
+        case "server_tool_use":
+        case "web_search_result":
+            return null;
+        case "text_start":
+        case "text_delta":
+        case "text_end":
+        case "thinking_start":
+        case "thinking_delta":
+        case "thinking_end":
+            return {
+                ...event,
+                contentIndex: remapClaudeCodeContentIndex(event.partial.content, event.contentIndex),
+                partial: sanitizeClaudeCodePartial(event.partial),
+            };
+        default:
+            return event;
+    }
+}
+export function buildFinalClaudeCodeContent(blocks, lastThinkingContent, lastTextContent, resultText) {
+    const finalContent = filterUserFacingClaudeCodeContent(blocks);
+    if (finalContent.length > 0)
+        return finalContent;
+    if (lastThinkingContent) {
+        finalContent.push({ type: "thinking", thinking: lastThinkingContent });
+    }
+    if (lastTextContent) {
+        finalContent.push({ type: "text", text: lastTextContent });
+    }
+    if (finalContent.length === 0 && resultText) {
+        finalContent.push({ type: "text", text: resultText });
+    }
+    return finalContent;
+}
 // ---------------------------------------------------------------------------
 // SDK options builder
 // ---------------------------------------------------------------------------
@@ -133,6 +198,7 @@ export function makeStreamExhaustedErrorMessage(model, lastTextContent) {
  * beta flags, and other configuration without mocking the full SDK.
  */
 export function buildSdkOptions(modelId, prompt) {
+    const mcpServers = buildWorkflowMcpServers();
     return {
         pathToClaudeCodeExecutable: getClaudePath(),
         model: modelId,
@@ -143,6 +209,7 @@ export function buildSdkOptions(modelId, prompt) {
         allowDangerouslySkipPermissions: true,
         settingSources: ["project"],
         systemPrompt: { type: "preset", preset: "claude_code" },
+        ...(mcpServers ? { mcpServers } : {}),
         betas: modelId.includes("sonnet") ? ["context-1m-2025-08-07"] : [],
     };
 }
@@ -167,8 +234,6 @@ async function pumpSdkMessages(model, context, options, stream) {
     /** Track the last text content seen across all assistant turns for the final message. */
     let lastTextContent = "";
     let lastThinkingContent = "";
-    /** Collect tool calls from intermediate SDK turns for tool_execution events. */
-    const intermediateToolCalls = [];
     try {
         // Dynamic import — the SDK is an optional dependency.
         const sdkModule = "@anthropic-ai/claude-agent-sdk";
@@ -220,16 +285,11 @@ async function pumpSdkMessages(model, context, options, stream) {
                     if (!builder)
                         break;
                     const assistantEvent = builder.handleEvent(event);
-                    if (assistantEvent) {
-                        // Skip toolcall events — the agent loop's externalToolExecution
-                        // path emits tool_execution_start/end events after streamSimple
-                        // returns. Streaming toolcall events would render tool calls
-                        // out of order in the TUI's accumulated message content.
-                        const t = assistantEvent.type;
-                        if (t !== "toolcall_start" && t !== "toolcall_delta" && t !== "toolcall_end") {
-                            stream.push(assistantEvent);
-                        }
-                    }
+                    const sanitizedEvent = assistantEvent
+                        ? sanitizeClaudeCodeStreamingEvent(assistantEvent)
+                        : null;
+                    if (sanitizedEvent)
+                        stream.push(sanitizedEvent);
                     break;
                 }
                 // -- Complete assistant message (non-streaming fallback) --
@@ -257,10 +317,6 @@ async function pumpSdkMessages(model, context, options, stream) {
                             else if (block.type === "thinking" && block.thinking) {
                                 lastThinkingContent = block.thinking;
                             }
-                            else if (block.type === "toolCall") {
-                                // Collect tool calls for externalToolExecution rendering
-                                intermediateToolCalls.push(block);
-                            }
                         }
                     }
                     builder = null;
@@ -269,32 +325,7 @@ async function pumpSdkMessages(model, context, options, stream) {
                 // -- Result (terminal) --
                 case "result": {
                     const result = msg;
-                    // Build final message. Include intermediate tool calls so the
-                    // agent loop's externalToolExecution path emits tool_execution
-                    // events for proper TUI rendering, followed by the text response.
-                    const finalContent = [];
-                    // Add tool calls from intermediate turns first (renders above text)
-                    finalContent.push(...intermediateToolCalls);
-                    // Add text/thinking from the last turn
-                    if (builder && builder.message.content.length > 0) {
-                        for (const block of builder.message.content) {
-                            if (block.type === "text" || block.type === "thinking") {
-                                finalContent.push(block);
-                            }
-                        }
-                    }
-                    else {
-                        if (lastThinkingContent) {
-                            finalContent.push({ type: "thinking", thinking: lastThinkingContent });
-                        }
-                        if (lastTextContent) {
-                            finalContent.push({ type: "text", text: lastTextContent });
-                        }
-                    }
-                    // Fallback: use the SDK's result text if we have no content
-                    if (finalContent.length === 0 && result.subtype === "success" && result.result) {
-                        finalContent.push({ type: "text", text: result.result });
-                    }
+                    const finalContent = buildFinalClaudeCodeContent(builder?.message.content ?? [], lastThinkingContent, lastTextContent, result.subtype === "success" ? result.result : undefined);
                     const finalMessage = {
                         role: "assistant",
                         content: finalContent,

package/dist/resources/extensions/get-secrets-from-user.js

@@ -25,6 +25,12 @@ function maskPreview(value) {
 function shellEscapeSingle(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
+function isSafeEnvVarKey(key) {
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(key);
+}
+function isSupportedDeploymentEnvironment(env) {
+    return env === "development" || env === "preview" || env === "production";
+}
 function hydrateProcessEnv(key, value) {
     // Make newly collected secrets immediately visible to the current session.
     // Some extensions read process.env directly and do not reload .env on every call.
@@ -263,12 +269,22 @@ async function applySecrets(provided, destination, opts) {
     }
     if ((destination === "vercel" || destination === "convex") && opts.exec) {
         const env = opts.environment ?? "development";
+        if (!isSupportedDeploymentEnvironment(env)) {
+            errors.push(`environment: unsupported target environment "${env}"`);
+            return { applied, errors };
+        }
         for (const { key, value } of provided) {
+            if (!isSafeEnvVarKey(key)) {
+                errors.push(`${key}: invalid environment variable name`);
+                continue;
+            }
             const cmd = destination === "vercel"
                 ? `printf %s ${shellEscapeSingle(value)} | vercel env add ${key} ${env}`
-                : `npx convex env set ${key} ${shellEscapeSingle(value)}`;
+                : "";
             try {
-                const result = await opts.exec("sh", ["-c", cmd]);
+                const result = destination === "vercel"
+                    ? await opts.exec("sh", ["-c", cmd])
+                    : await opts.exec("npx", ["convex", "env", "set", key, value]);
                 if (result.code !== 0) {
                     errors.push(`${key}: ${result.stderr.slice(0, 200)}`);
                 }

package/dist/resources/extensions/gsd/auto/phases.js

@@ -27,6 +27,7 @@ import { isDbAvailable, getMilestoneSlices } from "../gsd-db.js";
 import { resetEvidence } from "../safety/evidence-collector.js";
 import { createCheckpoint, cleanupCheckpoint, rollbackToCheckpoint } from "../safety/git-checkpoint.js";
 import { resolveSafetyHarnessConfig } from "../safety/safety-harness.js";
+import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForAutoUnit, } from "../workflow-mcp.js";
 // ─── generateMilestoneReport ──────────────────────────────────────────────────
 /**
  * Resolve the base path for milestone reports.
@@ -886,6 +887,22 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     s.currentDispatchedModelId = s.currentUnitModel
         ? `${s.currentUnitModel.provider ?? ""}/${s.currentUnitModel.id ?? ""}`
         : null;
+    const compatibilityError = getWorkflowTransportSupportError(s.currentUnitModel?.provider ?? ctx.model?.provider, getRequiredWorkflowToolsForAutoUnit(unitType), {
+        projectRoot: s.basePath,
+        surface: "auto-mode",
+        unitType,
+        authMode: s.currentUnitModel?.provider
+            ? ctx.modelRegistry.getProviderAuthMode(s.currentUnitModel.provider)
+            : ctx.model?.provider
+                ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider)
+                : undefined,
+        baseUrl: s.currentUnitModel?.baseUrl ?? ctx.model?.baseUrl,
+    });
+    if (compatibilityError) {
+        ctx.ui.notify(compatibilityError, "error");
+        await deps.stopAuto(ctx, pi, compatibilityError);
+        return { action: "break", reason: "workflow-capability" };
+    }
     // Progress widget + preconditions — deferred to after model selection so the
     // widget's first render tick shows the correct model (#2899).
     deps.updateProgressWidget(ctx, unitType, unitId, state);

package/dist/resources/extensions/gsd/auto-direct-dispatch.js

@@ -10,6 +10,7 @@ import { resolveMilestoneFile, resolveSliceFile, relSliceFile, } from "./paths.j
 import { buildResearchSlicePrompt, buildResearchMilestonePrompt, buildPlanSlicePrompt, buildPlanMilestonePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildReassessRoadmapPrompt, buildRunUatPrompt, buildReplanSlicePrompt, } from "./auto-prompts.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { pauseAuto } from "./auto.js";
+import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForAutoUnit, } from "./workflow-mcp.js";
 export async function dispatchDirectPhase(ctx, pi, phase, base) {
     const state = await deriveState(base);
     const mid = state.activeMilestone?.id;
@@ -202,6 +203,17 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             ctx.ui.notify(`Unknown phase "${phase}". Valid phases: research, plan, execute, complete, reassess, uat, replan.`, "warning");
             return;
     }
+    const compatibilityError = getWorkflowTransportSupportError(ctx.model?.provider, getRequiredWorkflowToolsForAutoUnit(unitType), {
+        projectRoot: base,
+        surface: "direct phase dispatch",
+        unitType,
+        authMode: ctx.model?.provider ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider) : undefined,
+        baseUrl: ctx.model?.baseUrl,
+    });
+    if (compatibilityError) {
+        ctx.ui.notify(compatibilityError, "error");
+        return;
+    }
     ctx.ui.notify(`Dispatching ${unitType} for ${unitId}...`, "info");
     const result = await ctx.newSession();
     if (result.cancelled) {

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -40,6 +40,7 @@ import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { getSliceTasks } from "./gsd-db.js";
 import { runPreExecutionChecks } from "./pre-execution-checks.js";
 import { writePreExecutionEvidence } from "./verification-evidence.js";
+import { ensureCodebaseMapFresh } from "./codebase-generator.js";
 /** Maximum verification retry attempts before escalating to blocker placeholder (#2653). */
 const MAX_VERIFICATION_RETRIES = 3;
 /** Enqueue a sidecar item (hook, triage, or quick-task) for the main loop to
@@ -553,6 +554,31 @@ export async function postUnitPreVerification(pctx, opts) {
  */
 export async function postUnitPostVerification(pctx) {
     const { s, ctx, pi, buildSnapshotOpts, lockBase, stopAuto, pauseAuto, updateProgressWidget } = pctx;
+    if (s.currentUnit) {
+        try {
+            const codebasePrefs = loadEffectiveGSDPreferences()?.preferences?.codebase;
+            const refresh = ensureCodebaseMapFresh(s.basePath, codebasePrefs
+                ? {
+                    excludePatterns: codebasePrefs.exclude_patterns,
+                    maxFiles: codebasePrefs.max_files,
+                    collapseThreshold: codebasePrefs.collapse_threshold,
+                }
+                : undefined, { force: true, ttlMs: 0 });
+            if (refresh.status === "generated" || refresh.status === "updated") {
+                debugLog("postUnit", {
+                    phase: "codebase-refresh",
+                    unitType: s.currentUnit.type,
+                    unitId: s.currentUnit.id,
+                    status: refresh.status,
+                    fileCount: refresh.fileCount,
+                    reason: refresh.reason,
+                });
+            }
+        }
+        catch (e) {
+            logWarning("engine", `CODEBASE refresh failed: ${e.message}`);
+        }
+    }
     // ── Post-unit hooks ──
     if (s.currentUnit && !s.stepMode) {
         const hookUnit = checkPostUnitHooks(s.currentUnit.type, s.currentUnit.id, s.basePath);