gsd-pi 2.78.0 → 2.78.1-dev.82bcf6b71

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

@@ -1,11 +1,12 @@
 import { Type } from "@sinclair/typebox";
 import { Text } from "@gsd/pi-tui";
-import { findMilestoneIds, nextMilestoneId, claimReservedId, getReservedMilestoneIds } from "../guided-flow.js";
 import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { ensureDbOpen } from "./dynamic-tools.js";
 import { StringEnum } from "@gsd/pi-ai";
 import { logError } from "../workflow-logger.js";
-import { executeCompleteMilestone, executePlanMilestone, executePlanSlice, executeReplanSlice, executeReassessRoadmap, executeSaveGateResult, executeSliceComplete, executeSummarySave, executeTaskComplete, executeValidateMilestone, } from "../tools/workflow-tool-executors.js";
+async function loadWorkflowExecutors() {
+    return import("../tools/workflow-tool-executors.js");
+}
 /**
  * Register an alias tool that shares the same execute function as its canonical counterpart.
  * The alias description and promptGuidelines direct the LLM to prefer the canonical name.
@@ -280,6 +281,7 @@ export function registerDbTools(pi) {
     registerAlias(pi, requirementSaveTool, "gsd_save_requirement", "gsd_requirement_save");
     // ─── gsd_summary_save (formerly gsd_save_summary) ──────────────────────
     const summarySaveExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+        const { executeSummarySave } = await loadWorkflowExecutors();
         return executeSummarySave(params, process.cwd());
     };
     const summarySaveTool = {
@@ -330,6 +332,7 @@ export function registerDbTools(pi) {
         try {
             // Claim a reserved ID if the guided-flow already previewed one to the user.
             // This guarantees the ID shown in the UI matches the one materialised on disk.
+            const { claimReservedId, findMilestoneIds, getReservedMilestoneIds, nextMilestoneId } = await import("../guided-flow.js");
             const reserved = claimReservedId();
             if (reserved) {
                 await ensureMilestoneDbRow(reserved);
@@ -408,6 +411,7 @@ export function registerDbTools(pi) {
     registerAlias(pi, milestoneGenerateIdTool, "gsd_generate_milestone_id", "gsd_milestone_generate_id");
     // ─── gsd_plan_milestone (gsd_milestone_plan alias) ─────────────────────
     const planMilestoneExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+        const { executePlanMilestone } = await loadWorkflowExecutors();
         return executePlanMilestone(params, process.cwd());
     };
     const planMilestoneTool = {
@@ -472,6 +476,7 @@ export function registerDbTools(pi) {
     registerAlias(pi, planMilestoneTool, "gsd_milestone_plan", "gsd_plan_milestone");
     // ─── gsd_plan_slice (gsd_slice_plan alias) ─────────────────────────────
     const planSliceExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+        const { executePlanSlice } = await loadWorkflowExecutors();
         return executePlanSlice(params, process.cwd());
     };
     const planSliceTool = {
@@ -585,6 +590,7 @@ export function registerDbTools(pi) {
     registerAlias(pi, planTaskTool, "gsd_task_plan", "gsd_plan_task");
     // ─── gsd_task_complete (gsd_complete_task alias) ────────────────────────
     const taskCompleteExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+        const { executeTaskComplete } = await loadWorkflowExecutors();
         return executeTaskComplete(params, process.cwd());
     };
     const taskCompleteTool = {
@@ -647,6 +653,7 @@ export function registerDbTools(pi) {
     registerAlias(pi, taskCompleteTool, "gsd_complete_task", "gsd_task_complete");
     // ─── gsd_slice_complete (gsd_complete_slice alias) ─────────────────────
     const sliceCompleteExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+        const { executeSliceComplete } = await loadWorkflowExecutors();
         return executeSliceComplete(params, process.cwd());
     };
     const sliceCompleteTool = {
@@ -811,6 +818,7 @@ export function registerDbTools(pi) {
     });
     // ─── gsd_complete_milestone ────────────────────────────────────────────
     const milestoneCompleteExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+        const { executeCompleteMilestone } = await loadWorkflowExecutors();
         return executeCompleteMilestone(params, process.cwd());
     };
     const milestoneCompleteTool = {
@@ -851,6 +859,7 @@ export function registerDbTools(pi) {
     registerAlias(pi, milestoneCompleteTool, "gsd_milestone_complete", "gsd_complete_milestone");
     // ─── gsd_validate_milestone (gsd_milestone_validate alias) ─────────────
     const milestoneValidateExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+        const { executeValidateMilestone } = await loadWorkflowExecutors();
         return executeValidateMilestone(params, process.cwd());
     };
     const milestoneValidateTool = {
@@ -883,6 +892,7 @@ export function registerDbTools(pi) {
     registerAlias(pi, milestoneValidateTool, "gsd_milestone_validate", "gsd_validate_milestone");
     // ─── gsd_replan_slice (gsd_slice_replan alias) ─────────────────────────
     const replanSliceExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+        const { executeReplanSlice } = await loadWorkflowExecutors();
         return executeReplanSlice(params, process.cwd());
     };
     const replanSliceTool = {
@@ -925,6 +935,7 @@ export function registerDbTools(pi) {
     registerAlias(pi, replanSliceTool, "gsd_slice_replan", "gsd_replan_slice");
     // ─── gsd_reassess_roadmap (gsd_roadmap_reassess alias) ─────────────────
     const reassessRoadmapExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+        const { executeReassessRoadmap } = await loadWorkflowExecutors();
         return executeReassessRoadmap(params, process.cwd());
     };
     const reassessRoadmapTool = {
@@ -1157,6 +1168,7 @@ export function registerDbTools(pi) {
     registerAlias(pi, reopenMilestoneTool, "gsd_reopen_milestone", "gsd_milestone_reopen");
     // ─── gsd_save_gate_result ──────────────────────────────────────────────
     const saveGateResultExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+        const { executeSaveGateResult } = await loadWorkflowExecutors();
         return executeSaveGateResult(params, process.cwd());
     };
     const saveGateResultTool = {

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

@@ -3,11 +3,6 @@
 // Exposes the `gsd_exec` tool over MCP. Opt-in: disabled unless
 // `context_mode.enabled: true` is set in preferences.
 import { Type } from "@sinclair/typebox";
-import { executeGsdExec } from "../tools/exec-tool.js";
-import { executeExecSearch } from "../tools/exec-search-tool.js";
-import { executeResume } from "../tools/resume-tool.js";
-import { loadEffectiveGSDPreferences } from "../preferences.js";
-import { logWarning } from "../workflow-logger.js";
 export function registerExecTools(pi) {
     pi.registerTool({
         name: "gsd_exec",
@@ -35,6 +30,11 @@ export function registerExecTools(pi) {
             })),
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            const [{ executeGsdExec }, { loadEffectiveGSDPreferences }, { logWarning }] = await Promise.all([
+                import("../tools/exec-tool.js"),
+                import("../preferences.js"),
+                import("../workflow-logger.js"),
+            ]);
             let prefs = null;
             try {
                 prefs = loadEffectiveGSDPreferences();
@@ -67,6 +67,7 @@ export function registerExecTools(pi) {
             limit: Type.Optional(Type.Number({ description: "Max results (default 20, cap 200)", minimum: 1, maximum: 200 })),
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            const { executeExecSearch } = await import("../tools/exec-search-tool.js");
             return executeExecSearch(params, {
                 baseDir: process.cwd(),
             });
@@ -85,6 +86,7 @@ export function registerExecTools(pi) {
         ],
         parameters: Type.Object({}),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            const { executeResume } = await import("../tools/resume-tool.js");
             return executeResume(params, {
                 baseDir: process.cwd(),
             });

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

@@ -1,8 +1,6 @@
 // GSD2 — Read-only query tools exposing DB state to the LLM via the WAL connection
 import { Type } from "@sinclair/typebox";
 import { ensureDbOpen } from "./dynamic-tools.js";
-import { executeMilestoneStatus } from "../tools/workflow-tool-executors.js";
-import { checkpointDatabase } from "../gsd-db.js";
 export function registerQueryTools(pi) {
     pi.registerTool({
         name: "gsd_milestone_status",
@@ -25,6 +23,7 @@ export function registerQueryTools(pi) {
                     details: { operation: "milestone_status", error: "db_unavailable" },
                 };
             }
+            const { executeMilestoneStatus } = await import("../tools/workflow-tool-executors.js");
             return executeMilestoneStatus(params);
         },
     });
@@ -49,6 +48,7 @@ export function registerQueryTools(pi) {
                     details: { operation: "checkpoint_db", error: "db_unavailable" },
                 };
             }
+            const { checkpointDatabase } = await import("../gsd-db.js");
             checkpointDatabase();
             return {
                 content: [{ type: "text", text: "WAL checkpoint complete. gsd.db is now up to date and safe to stage with git add." }],

package/dist/resources/extensions/gsd/bootstrap/register-extension.js

@@ -1,7 +1,6 @@
 // GSD2 — Extension registration: wires all GSD tools, commands, and hooks into pi
 import { registerExitCommand } from "../exit-command.js";
-import { registerWorktreeCommand } from "../worktree-command.js";
-import { loadEcosystemExtensions } from "../ecosystem/loader.js";
+import { registerLazyWorktreeCommands } from "../worktree-command-bootstrap.js";
 import { registerDbTools } from "./db-tools.js";
 import { registerDynamicTools } from "./dynamic-tools.js";
 import { registerExecTools } from "./exec-tools.js";
@@ -64,7 +63,7 @@ function installEpipeGuard() {
 export function registerGsdExtension(pi) {
     // Note: registerGSDCommand is called by index.ts before this function,
     // so we intentionally skip it here to avoid double-registration.
-    registerWorktreeCommand(pi);
+    registerLazyWorktreeCommands(pi);
     registerExitCommand(pi);
     // Wire the Layer 2 event emitter bridge so deeply-nested GSD code can emit
     // extension events (git lifecycle, verify, budget, milestone, unit) without
@@ -102,7 +101,9 @@ export function registerGsdExtension(pi) {
         ["cmux-events", () => initCmuxEventListeners(pi.events)],
         ["hooks", () => registerHooks(pi, ecosystemHandlers)],
         ["ecosystem", () => {
-                void loadEcosystemExtensions(pi, ecosystemHandlers).catch((err) => {
+                void import("../ecosystem/loader.js")
+                    .then(({ loadEcosystemExtensions }) => loadEcosystemExtensions(pi, ecosystemHandlers))
+                    .catch((err) => {
                     logWarning("ecosystem", `loader failed: ${err instanceof Error ? err.message : String(err)}`);
                 });
             }],

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -1,22 +1,14 @@
 import { join } from "node:path";
 import { isToolCallEventType } from "@gsd/pi-coding-agent";
 import { updateSnapshot } from "../ecosystem/gsd-extension-api.js";
-import { getEcosystemReadyPromise } from "../ecosystem/loader.js";
 import { buildMilestoneFileName, resolveMilestonePath, resolveSliceFile, resolveSlicePath } from "../paths.js";
-import { buildBeforeAgentStartResult } from "./system-context.js";
-import { handleAgentEnd } from "./agent-end-recovery.js";
-import { clearDiscussionFlowState, isDepthConfirmationAnswer, isQueuePhaseActive, markDepthVerified, resetWriteGateState, shouldBlockContextWrite, shouldBlockQueueExecution, isGateQuestionId, setPendingGate, clearPendingGate, getPendingGate, shouldBlockPendingGate, shouldBlockPendingGateBash, extractDepthVerificationMilestoneId } from "./write-gate.js";
+import { clearDiscussionFlowState, isDepthConfirmationAnswer, isQueuePhaseActive, markDepthVerified, resetWriteGateState, shouldBlockContextWrite, shouldBlockPlanningUnit, shouldBlockQueueExecution, isGateQuestionId, setPendingGate, clearPendingGate, getPendingGate, shouldBlockPendingGate, shouldBlockPendingGateBash, extractDepthVerificationMilestoneId } from "./write-gate.js";
+import { resolveManifest } from "../unit-context-manifest.js";
 import { isBlockedStateFile, isBashWriteToStateFile, BLOCKED_WRITE_ERROR } from "../write-intercept.js";
-import { cleanupQuickBranch } from "../quick.js";
-import { getDiscussionMilestoneId } from "../guided-flow.js";
-import { loadToolApiKeys } from "../commands-config.js";
 import { loadFile, saveFile, formatContinue } from "../files.js";
-import { deriveState } from "../state.js";
-import { getAutoDashboardData, isAutoActive, isAutoPaused, markToolEnd, markToolStart, recordToolInvocationError } from "../auto.js";
-import { isParallelActive, shutdownParallel } from "../parallel-orchestrator.js";
+import { getAutoRuntimeSnapshot, isAutoActive, isAutoPaused, markToolEnd, markToolStart, recordToolInvocationError } from "../auto-runtime-state.js";
 import { checkToolCallLoop, resetToolCallLoopGuard } from "./tool-call-loop-guard.js";
 import { saveActivityLog } from "../activity-log.js";
-import { resetAskUserQuestionsCache } from "../../ask-user-questions.js";
 import { recordToolCall as safetyRecordToolCall, recordToolResult as safetyRecordToolResult, saveEvidenceToDisk } from "../safety/evidence-collector.js";
 import { parseUnitId } from "../unit-id.js";
 import { classifyCommand } from "../safety/destructive-guard.js";
@@ -24,26 +16,53 @@ import { logWarning as safetyLogWarning } from "../workflow-logger.js";
 import { installNotifyInterceptor } from "./notify-interceptor.js";
 import { initNotificationStore } from "../notification-store.js";
 import { initNotificationWidget } from "../notification-widget.js";
-import { initHealthWidget } from "../health-widget.js";
+import { extractSubagentAgentClasses } from "./subagent-input.js";
 // Skip the welcome screen on the very first session_start — cli.ts already
 // printed it before the TUI launched. Only re-print on /clear (subsequent sessions).
 let isFirstSession = true;
+async function deriveGsdState(basePath) {
+    const { deriveState } = await import("../state.js");
+    return deriveState(basePath);
+}
+async function getDiscussionMilestoneIdFor(basePath) {
+    const { getDiscussionMilestoneId } = await import("../guided-flow.js");
+    return getDiscussionMilestoneId(basePath);
+}
+async function loadToolApiKeysForSession() {
+    const { loadToolApiKeys } = await import("../commands-config.js");
+    loadToolApiKeys();
+}
+async function resetAskUserQuestionsTurnCache() {
+    const { resetAskUserQuestionsCache } = await import("../../ask-user-questions.js");
+    resetAskUserQuestionsCache();
+}
 async function syncServiceTierStatus(ctx) {
     const { getEffectiveServiceTier, formatServiceTierFooterStatus } = await import("../service-tier.js");
     ctx.ui.setStatus("gsd-fast", formatServiceTierFooterStatus(getEffectiveServiceTier(), ctx.model?.id));
 }
+async function applyDisabledModelProviderPolicy(ctx) {
+    try {
+        const { resolveDisabledModelProvidersFromPreferences } = await import("../preferences.js");
+        ctx.modelRegistry.setDisabledModelProviders(resolveDisabledModelProvidersFromPreferences());
+    }
+    catch {
+        // Non-fatal: keep default provider visibility if preferences cannot be loaded.
+    }
+}
 export function registerHooks(pi, ecosystemHandlers) {
     pi.on("session_start", async (_event, ctx) => {
         initNotificationStore(process.cwd());
         installNotifyInterceptor(ctx);
         initNotificationWidget(ctx);
         if (!isAutoActive()) {
+            const { initHealthWidget } = await import("../health-widget.js");
             initHealthWidget(ctx);
         }
         resetWriteGateState();
         resetToolCallLoopGuard();
-        resetAskUserQuestionsCache();
+        await resetAskUserQuestionsTurnCache();
         await syncServiceTierStatus(ctx);
+        await applyDisabledModelProviderPolicy(ctx);
         // Skip MCP auto-prep when running inside an auto-worktree (see session_switch below).
         const { isInAutoWorktree } = await import("../auto-worktree.js");
         if (!isInAutoWorktree(process.cwd())) {
@@ -79,7 +98,7 @@ export function registerHooks(pi, ecosystemHandlers) {
             }
             catch { /* non-fatal */ }
         }
-        loadToolApiKeys();
+        await loadToolApiKeysForSession();
         if (isAutoActive()) {
             ctx.ui.setWidget("gsd-health", undefined);
         }
@@ -89,9 +108,10 @@ export function registerHooks(pi, ecosystemHandlers) {
         installNotifyInterceptor(ctx);
         resetWriteGateState();
         resetToolCallLoopGuard();
-        resetAskUserQuestionsCache();
+        await resetAskUserQuestionsTurnCache();
         clearDiscussionFlowState();
         await syncServiceTierStatus(ctx);
+        await applyDisabledModelProviderPolicy(ctx);
         // Skip MCP auto-prep when running inside an auto-worktree. The worktree
         // already has .mcp.json from createAutoWorktree, and re-running the writer
         // post-chdir rewrites the file mid-run (non-idempotent due to cwd-relative
@@ -101,20 +121,26 @@ export function registerHooks(pi, ecosystemHandlers) {
             const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
             prepareWorkflowMcpForProject(ctx, process.cwd());
         }
-        loadToolApiKeys();
-        if (isAutoActive()) {
+        await loadToolApiKeysForSession();
+        if (!isAutoActive()) {
+            const { initHealthWidget } = await import("../health-widget.js");
+            initHealthWidget(ctx);
+        }
+        else {
             ctx.ui.setWidget("gsd-health", undefined);
         }
     });
     pi.on("before_agent_start", async (event, ctx) => {
         // Wait for ecosystem loader to finish (no-op after first turn).
+        const { getEcosystemReadyPromise } = await import("../ecosystem/loader.js");
         await getEcosystemReadyPromise();
         // GSD's own context injection (existing behavior — unchanged).
+        const { buildBeforeAgentStartResult } = await import("./system-context.js");
         const gsdResult = await buildBeforeAgentStartResult(event, ctx);
         // Refresh the snapshot used by ecosystem getPhase()/getActiveUnit().
         // deriveState has its own ~100ms cache so this is cheap on repeat calls.
         try {
-            const state = await deriveState(process.cwd());
+            const state = await deriveGsdState(process.cwd());
             updateSnapshot(state);
         }
         catch {
@@ -148,7 +174,8 @@ export function registerHooks(pi, ecosystemHandlers) {
     });
     pi.on("agent_end", async (event, ctx) => {
         resetToolCallLoopGuard();
-        resetAskUserQuestionsCache();
+        await resetAskUserQuestionsTurnCache();
+        const { handleAgentEnd } = await import("./agent-end-recovery.js");
         await handleAgentEnd(pi, event, ctx);
     });
     // Squash-merge quick-task branch back to the original branch after the
@@ -156,6 +183,7 @@ export function registerHooks(pi, ecosystemHandlers) {
     // quick-return state is pending, so this is safe to call on every turn.
     pi.on("turn_end", async () => {
         try {
+            const { cleanupQuickBranch } = await import("../quick.js");
             cleanupQuickBranch();
         }
         catch {
@@ -172,8 +200,8 @@ export function registerHooks(pi, ecosystemHandlers) {
         const basePath = process.cwd();
         const { ensureDbOpen } = await import("./dynamic-tools.js");
         await ensureDbOpen();
-        const state = await deriveState(basePath);
-        if (!state.activeMilestone || !state.activeSlice || !state.activeTask)
+        const state = await deriveGsdState(basePath);
+        if (!state.activeMilestone || !state.activeSlice)
             return;
         // Write checkpoint for ALL phases, not just "executing" — discuss, research,
         // and planning also carry in-memory state (user answers, gate verification)
@@ -189,21 +217,30 @@ export function registerHooks(pi, ecosystemHandlers) {
         if (await loadFile(legacyContinue))
             return;
         const continuePath = join(sliceDir, `${state.activeSlice.id}-CONTINUE.md`);
+        const taskId = state.activeTask?.id ?? "none";
+        const taskTitle = state.activeTask?.title ?? "";
+        const phaseLabel = state.phase.replace(/-/g, " ");
         await saveFile(continuePath, formatContinue({
             frontmatter: {
                 milestone: state.activeMilestone.id,
                 slice: state.activeSlice.id,
-                task: state.activeTask.id,
+                task: taskId,
                 step: 0,
                 totalSteps: 0,
                 status: "compacted",
                 savedAt: new Date().toISOString(),
             },
-            completedWork: `Task ${state.activeTask.id} (${state.activeTask.title}) was in progress when compaction occurred.`,
-            remainingWork: "Check the task plan for remaining steps.",
+            completedWork: state.activeTask
+                ? `Task ${taskId} (${taskTitle}) was in progress when compaction occurred.`
+                : `Slice ${state.activeSlice.id} was in ${phaseLabel} phase when compaction occurred.`,
+            remainingWork: state.activeTask
+                ? "Check the task plan for remaining steps."
+                : "Continue this slice from the latest planning/research/discussion artifacts.",
             decisions: "Check task summary files for prior decisions.",
             context: "Session was auto-compacted by Pi. Resume with /gsd.",
-            nextAction: `Resume task ${state.activeTask.id}: ${state.activeTask.title}.`,
+            nextAction: state.activeTask
+                ? `Resume task ${taskId}: ${taskTitle}.`
+                : `Resume ${phaseLabel} work for slice ${state.activeSlice.id}.`,
         }));
     });
     // Context-mode snapshot: write .gsd/last-snapshot.md before compaction so
@@ -225,7 +262,7 @@ export function registerHooks(pi, ecosystemHandlers) {
             const basePath = process.cwd();
             let activeContext = null;
             try {
-                const state = await deriveState(basePath);
+                const state = await deriveGsdState(basePath);
                 if (state.activeMilestone && state.activeSlice && state.activeTask) {
                     activeContext =
                         `Active: ${state.activeMilestone.id} / ${state.activeSlice.id} / ${state.activeTask.id}` +
@@ -242,6 +279,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         }
     });
     pi.on("session_shutdown", async (_event, ctx) => {
+        const { isParallelActive, shutdownParallel } = await import("../parallel-orchestrator.js");
         if (isParallelActive()) {
             try {
                 await shutdownParallel(process.cwd());
@@ -252,7 +290,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         }
         if (!isAutoActive() && !isAutoPaused())
             return;
-        const dash = getAutoDashboardData();
+        const dash = getAutoRuntimeSnapshot();
         if (dash.currentUnit) {
             saveActivityLog(ctx, dash.basePath, dash.currentUnit.type, dash.currentUnit.id);
         }
@@ -278,7 +316,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         // If ask_user_questions was called with a gate ID but hasn't been confirmed,
         // block all non-read-only tool calls to prevent the model from skipping gates.
         if (getPendingGate()) {
-            const milestoneId = getDiscussionMilestoneId(discussionBasePath);
+            const milestoneId = await getDiscussionMilestoneIdFor(discussionBasePath);
             if (isToolCallEventType("bash", event)) {
                 const bashGuard = shouldBlockPendingGateBash(event.input.command, milestoneId, isQueuePhaseActive());
                 if (bashGuard.block)
@@ -309,6 +347,37 @@ export function registerHooks(pi, ecosystemHandlers) {
             if (queueGuard.block)
                 return queueGuard;
         }
+        // ── Planning-unit tools-policy enforcement (#4934): runtime half ─────
+        // The active auto-mode unit's manifest declares a ToolsPolicy. For
+        // planning/docs/read-only modes, deny writes outside .gsd/ (or the
+        // manifest's allowedPathGlobs), bash that isn't read-only, and
+        // subagent dispatch. Closes the b23 bug class where a discuss-milestone
+        // turn used the host Edit tool to modify user source files.
+        const dash = getAutoRuntimeSnapshot();
+        const activeUnitType = dash.currentUnit?.type;
+        if (activeUnitType) {
+            const manifest = resolveManifest(activeUnitType);
+            if (manifest) {
+                let planningInput = "";
+                let agentClasses;
+                if (isToolCallEventType("write", event)) {
+                    planningInput = event.input.path;
+                }
+                else if (isToolCallEventType("edit", event)) {
+                    planningInput = event.input.path;
+                }
+                else if (isToolCallEventType("bash", event)) {
+                    planningInput = event.input.command;
+                }
+                else if (event.toolName === "subagent" || event.toolName === "task") {
+                    // Subagent inputs use { agent }, { tasks: [{ agent }] }, or { chain: [{ agent }] }.
+                    agentClasses = extractSubagentAgentClasses(event.input);
+                }
+                const planningGuard = shouldBlockPlanningUnit(event.toolName, planningInput, dash.basePath || discussionBasePath, activeUnitType, manifest.tools, agentClasses);
+                if (planningGuard.block)
+                    return planningGuard;
+            }
+        }
         // ── Single-writer engine: block direct writes to STATE.md ──────────
         // Covers write, edit, and bash tools to prevent bypass vectors.
         if (isToolCallEventType("write", event)) {
@@ -328,7 +397,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         }
         if (!isToolCallEventType("write", event))
             return;
-        const result = shouldBlockContextWrite(event.toolName, event.input.path, getDiscussionMilestoneId(discussionBasePath), isQueuePhaseActive());
+        const result = shouldBlockContextWrite(event.toolName, event.input.path, await getDiscussionMilestoneIdFor(discussionBasePath), isQueuePhaseActive());
         if (result.block)
             return result;
     });
@@ -338,6 +407,18 @@ export function registerHooks(pi, ecosystemHandlers) {
             return;
         markToolStart(event.toolCallId, event.toolName);
         safetyRecordToolCall(event.toolCallId, event.toolName, event.input);
+        // Persist immediately at dispatch so a mid-unit re-dispatch — which calls
+        // resetEvidence() + loadEvidenceFromDisk() in runUnitPhase — cannot wipe
+        // the entry between tool_call and tool_execution_end. Without this, the
+        // race window equals the tool's runtime, producing the "no bash calls"
+        // false positive when the LLM clearly ran a verification command.
+        const callDash = getAutoRuntimeSnapshot();
+        if (callDash.basePath && callDash.currentUnit?.type === "execute-task") {
+            const { milestone: cMid, slice: cSid, task: cTid } = parseUnitId(callDash.currentUnit.id);
+            if (cMid && cSid && cTid) {
+                saveEvidenceToDisk(callDash.basePath, cMid, cSid, cTid);
+            }
+        }
         // Destructive command classification (warn only, never block)
         if (isToolCallEventType("bash", event)) {
             const classification = classifyCommand(event.input.command);
@@ -368,7 +449,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         }
         if (event.toolName !== "ask_user_questions")
             return;
-        const milestoneId = getDiscussionMilestoneId(process.cwd());
+        const milestoneId = await getDiscussionMilestoneIdFor(process.cwd());
         const queueActive = isQueuePhaseActive();
         const details = event.details;
         // ── Discussion gate enforcement: handle gate question responses ──
@@ -464,7 +545,7 @@ export function registerHooks(pi, ecosystemHandlers) {
             safetyRecordToolResult(event.toolCallId, event.toolName, event.result, event.isError);
             // Persist evidence to disk after each tool result so it survives a session
             // restart mid-unit (Bug #4385 — non-persisted evidence false positives).
-            const dash = getAutoDashboardData();
+            const dash = getAutoRuntimeSnapshot();
             if (dash.basePath && dash.currentUnit?.type === "execute-task") {
                 const { milestone: pMid, slice: pSid, task: pTid } = parseUnitId(dash.currentUnit.id);
                 if (pMid && pSid && pTid) {

package/dist/resources/extensions/gsd/bootstrap/register-shortcuts.js

@@ -1,12 +1,12 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { Key } from "@gsd/pi-tui";
-import { GSDDashboardOverlay } from "../dashboard-overlay.js";
-import { GSDNotificationOverlay } from "../notification-overlay.js";
-import { ParallelMonitorOverlay } from "../parallel-monitor-overlay.js";
 import { GSD_SHORTCUTS } from "../shortcut-defs.js";
-import { projectRoot } from "../commands/context.js";
 import { shortcutDesc } from "../../shared/mod.js";
+async function getProjectRoot() {
+    const { projectRoot } = await import("../commands/context.js");
+    return projectRoot();
+}
 export function registerShortcuts(pi) {
     const overlayOptions = {
         width: "90%",
@@ -15,7 +15,10 @@ export function registerShortcuts(pi) {
         anchor: "center",
     };
     const openDashboardOverlay = async (ctx) => {
-        const basePath = projectRoot();
+        const [{ GSDDashboardOverlay }, basePath] = await Promise.all([
+            import("../dashboard-overlay.js"),
+            getProjectRoot(),
+        ]);
         if (!existsSync(join(basePath, ".gsd"))) {
             ctx.ui.notify("No .gsd/ directory found. Run /gsd to start.", "info");
             return;
@@ -26,6 +29,7 @@ export function registerShortcuts(pi) {
         });
     };
     const openNotificationsOverlay = async (ctx) => {
+        const { GSDNotificationOverlay } = await import("../notification-overlay.js");
         await ctx.ui.custom((tui, theme, _kb, done) => new GSDNotificationOverlay(tui, theme, () => done(true)), {
             overlay: true,
             overlayOptions: {
@@ -38,12 +42,13 @@ export function registerShortcuts(pi) {
         });
     };
     const openParallelOverlay = async (ctx) => {
-        const basePath = projectRoot();
+        const basePath = await getProjectRoot();
         const parallelDir = join(basePath, ".gsd", "parallel");
         if (!existsSync(parallelDir)) {
             ctx.ui.notify("No parallel workers found. Run /gsd parallel start first.", "info");
             return;
         }
+        const { ParallelMonitorOverlay } = await import("../parallel-monitor-overlay.js");
         await ctx.ui.custom((tui, theme, _kb, done) => new ParallelMonitorOverlay(tui, theme, () => done(true), basePath), {
             overlay: true,
             overlayOptions,

package/dist/resources/extensions/gsd/bootstrap/subagent-input.js

@@ -0,0 +1,22 @@
+export function extractSubagentAgentClasses(input) {
+    if (!input || typeof input !== "object")
+        return [];
+    const record = input;
+    const agentClasses = [];
+    const addAgentClass = (value) => {
+        if (typeof value === "string" && value.trim().length > 0)
+            agentClasses.push(value.trim());
+    };
+    const addFromItems = (value) => {
+        if (!Array.isArray(value))
+            return;
+        for (const item of value) {
+            if (item && typeof item === "object")
+                addAgentClass(item.agent);
+        }
+    };
+    addAgentClass(record.agent);
+    addFromItems(record.tasks);
+    addFromItems(record.chain);
+    return agentClasses;
+}