gsd-pi 2.78.0 → 2.78.1-dev.8a893322c

package/src/resources/extensions/gsd/auto.ts

@@ -232,7 +232,6 @@ import { reorderForCaching } from "./prompt-ordering.js";
 // ─── Session State ─────────────────────────────────────────────────────────
 
 import {
-  AutoSession,
   STUB_RECOVERY_THRESHOLD,
   NEW_SESSION_TIMEOUT_MS,
 } from "./auto/session.js";
@@ -250,11 +249,12 @@ export type {
   UnitRouting,
   StartModel,
 } from "./auto/session.js";
+import { autoSession as s } from "./auto-runtime-state.js";
 
 // ── ENCAPSULATION INVARIANT ─────────────────────────────────────────────────
 // ALL mutable auto-mode state lives in the AutoSession class (auto/session.ts).
 // This file must NOT declare module-level `let` or `var` variables for state.
-// The single `s` instance below is the only mutable module-level binding.
+// The single shared `s` instance below is the only mutable AutoSession binding.
 //
 // When adding features or fixing bugs:
 //   - New mutable state → add a property to AutoSession, not a module-level variable
@@ -263,7 +263,6 @@ export type {
 //
 // Tests in auto-session-encapsulation.test.ts enforce this invariant.
 // ─────────────────────────────────────────────────────────────────────────────
-const s = new AutoSession();
 
 /** Throttle STATE.md rebuilds — at most once per 30 seconds */
 const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
@@ -1812,7 +1811,7 @@ const widgetStateAccessors: WidgetStateAccessors = {
  * Ensure directories, branches, and other prerequisites exist before
  * dispatching a unit. The LLM should never need to mkdir or git checkout.
  */
-function ensurePreconditions(
+export function ensurePreconditions(
   unitType: string,
   unitId: string,
   base: string,
@@ -1822,6 +1821,17 @@ function ensurePreconditions(
 
   const mDir = resolveMilestonePath(base, mid);
   if (!mDir) {
+    // Fix #4996: When dispatching a slice unit against an unrecognised milestone,
+    // only create the directory if the milestone has a DB row.
+    // Without this guard, forward-referenced unit IDs (e.g. from REQUIREMENTS.md)
+    // silently scaffold empty stub directories that later skew nextMilestoneId.
+    if (sid !== undefined) {
+      const hasDbRow = isDbAvailable() && getMilestone(mid) != null;
+      if (!hasDbRow) {
+        logWarning("engine", `ensurePreconditions: skipping mkdir for unrecognised milestone ${mid} referenced by slice unit ${unitId} — no DB row exists`, { file: "auto.ts" });
+        return;
+      }
+    }
     const newDir = join(milestonesDir(base), mid);
     mkdirSync(join(newDir, "slices"), { recursive: true });
   }

package/src/resources/extensions/gsd/bootstrap/db-tools.ts

@@ -2,24 +2,15 @@ import { Type } from "@sinclair/typebox";
 import type { ExtensionAPI } from "@gsd/pi-coding-agent";
 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 { getErrorMessage } from "../error-utils.js";
-import {
-  executeCompleteMilestone,
-  executePlanMilestone,
-  executePlanSlice,
-  executeReplanSlice,
-  executeReassessRoadmap,
-  executeSaveGateResult,
-  executeSliceComplete,
-  executeSummarySave,
-  executeTaskComplete,
-  executeValidateMilestone,
-} from "../tools/workflow-tool-executors.js";
+
+async function loadWorkflowExecutors(): Promise<typeof import("../tools/workflow-tool-executors.js")> {
+  return import("../tools/workflow-tool-executors.js");
+}
 
 /**
  * Register an alias tool that shares the same execute function as its canonical counterpart.
@@ -302,6 +293,7 @@ export function registerDbTools(pi: ExtensionAPI): void {
   // ─── gsd_summary_save (formerly gsd_save_summary) ──────────────────────
 
   const summarySaveExecute = async (_toolCallId: string, params: any, _signal: AbortSignal | undefined, _onUpdate: unknown, _ctx: unknown) => {
+    const { executeSummarySave } = await loadWorkflowExecutors();
     return executeSummarySave(params, process.cwd());
   };
 
@@ -354,6 +346,7 @@ export function registerDbTools(pi: ExtensionAPI): void {
     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);
@@ -435,6 +428,7 @@ export function registerDbTools(pi: ExtensionAPI): void {
   // ─── gsd_plan_milestone (gsd_milestone_plan alias) ─────────────────────
 
   const planMilestoneExecute = async (_toolCallId: string, params: any, _signal: AbortSignal | undefined, _onUpdate: unknown, _ctx: unknown) => {
+    const { executePlanMilestone } = await loadWorkflowExecutors();
     return executePlanMilestone(params, process.cwd());
   };
 
@@ -504,6 +498,7 @@ export function registerDbTools(pi: ExtensionAPI): void {
   // ─── gsd_plan_slice (gsd_slice_plan alias) ─────────────────────────────
 
   const planSliceExecute = async (_toolCallId: string, params: any, _signal: AbortSignal | undefined, _onUpdate: unknown, _ctx: unknown) => {
+    const { executePlanSlice } = await loadWorkflowExecutors();
     return executePlanSlice(params, process.cwd());
   };
 
@@ -626,6 +621,7 @@ export function registerDbTools(pi: ExtensionAPI): void {
   // ─── gsd_task_complete (gsd_complete_task alias) ────────────────────────
 
   const taskCompleteExecute = async (_toolCallId: string, params: any, _signal: AbortSignal | undefined, _onUpdate: unknown, _ctx: unknown) => {
+    const { executeTaskComplete } = await loadWorkflowExecutors();
     return executeTaskComplete(params, process.cwd());
   };
 
@@ -696,6 +692,7 @@ export function registerDbTools(pi: ExtensionAPI): void {
   // ─── gsd_slice_complete (gsd_complete_slice alias) ─────────────────────
 
   const sliceCompleteExecute = async (_toolCallId: string, params: any, _signal: AbortSignal | undefined, _onUpdate: unknown, _ctx: unknown) => {
+    const { executeSliceComplete } = await loadWorkflowExecutors();
     return executeSliceComplete(params, process.cwd());
   };
 
@@ -888,6 +885,7 @@ export function registerDbTools(pi: ExtensionAPI): void {
   // ─── gsd_complete_milestone ────────────────────────────────────────────
 
   const milestoneCompleteExecute = async (_toolCallId: string, params: any, _signal: AbortSignal | undefined, _onUpdate: unknown, _ctx: unknown) => {
+    const { executeCompleteMilestone } = await loadWorkflowExecutors();
     return executeCompleteMilestone(params, process.cwd());
   };
 
@@ -933,6 +931,7 @@ export function registerDbTools(pi: ExtensionAPI): void {
   // ─── gsd_validate_milestone (gsd_milestone_validate alias) ─────────────
 
   const milestoneValidateExecute = async (_toolCallId: string, params: any, _signal: AbortSignal | undefined, _onUpdate: unknown, _ctx: unknown) => {
+    const { executeValidateMilestone } = await loadWorkflowExecutors();
     return executeValidateMilestone(params, process.cwd());
   };
 
@@ -970,6 +969,7 @@ export function registerDbTools(pi: ExtensionAPI): void {
   // ─── gsd_replan_slice (gsd_slice_replan alias) ─────────────────────────
 
   const replanSliceExecute = async (_toolCallId: string, params: any, _signal: AbortSignal | undefined, _onUpdate: unknown, _ctx: unknown) => {
+    const { executeReplanSlice } = await loadWorkflowExecutors();
     return executeReplanSlice(params, process.cwd());
   };
 
@@ -1020,6 +1020,7 @@ export function registerDbTools(pi: ExtensionAPI): void {
   // ─── gsd_reassess_roadmap (gsd_roadmap_reassess alias) ─────────────────
 
   const reassessRoadmapExecute = async (_toolCallId: string, params: any, _signal: AbortSignal | undefined, _onUpdate: unknown, _ctx: unknown) => {
+    const { executeReassessRoadmap } = await loadWorkflowExecutors();
     return executeReassessRoadmap(params, process.cwd());
   };
 
@@ -1275,6 +1276,7 @@ export function registerDbTools(pi: ExtensionAPI): void {
   // ─── gsd_save_gate_result ──────────────────────────────────────────────
 
   const saveGateResultExecute = async (_toolCallId: string, params: any, _signal: AbortSignal | undefined, _onUpdate: unknown, _ctx: unknown) => {
+    const { executeSaveGateResult } = await loadWorkflowExecutors();
     return executeSaveGateResult(params, process.cwd());
   };
 

package/src/resources/extensions/gsd/bootstrap/exec-tools.ts

@@ -6,12 +6,6 @@
 import { Type } from "@sinclair/typebox";
 import type { ExtensionAPI } from "@gsd/pi-coding-agent";
 
-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: ExtensionAPI): void {
   pi.registerTool({
     name: "gsd_exec",
@@ -46,7 +40,12 @@ export function registerExecTools(pi: ExtensionAPI): void {
       ),
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-      let prefs: Awaited<ReturnType<typeof loadEffectiveGSDPreferences>> | null = null;
+      const [{ executeGsdExec }, { loadEffectiveGSDPreferences }, { logWarning }] = await Promise.all([
+        import("../tools/exec-tool.js"),
+        import("../preferences.js"),
+        import("../workflow-logger.js"),
+      ]);
+      let prefs: ReturnType<typeof loadEffectiveGSDPreferences> | null = null;
       try {
         prefs = loadEffectiveGSDPreferences();
       } catch (err) {
@@ -81,6 +80,7 @@ export function registerExecTools(pi: ExtensionAPI): void {
       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 as Parameters<typeof executeExecSearch>[0], {
         baseDir: process.cwd(),
       });
@@ -101,6 +101,7 @@ export function registerExecTools(pi: ExtensionAPI): void {
     ],
     parameters: Type.Object({}),
     async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+      const { executeResume } = await import("../tools/resume-tool.js");
       return executeResume(params as Parameters<typeof executeResume>[0], {
         baseDir: process.cwd(),
       });

package/src/resources/extensions/gsd/bootstrap/query-tools.ts

@@ -3,8 +3,6 @@
 import { Type } from "@sinclair/typebox";
 import type { ExtensionAPI } from "@gsd/pi-coding-agent";
 import { ensureDbOpen } from "./dynamic-tools.js";
-import { executeMilestoneStatus } from "../tools/workflow-tool-executors.js";
-import { checkpointDatabase } from "../gsd-db.js";
 
 export function registerQueryTools(pi: ExtensionAPI): void {
   pi.registerTool({
@@ -29,6 +27,7 @@ export function registerQueryTools(pi: ExtensionAPI): void {
           details: { operation: "milestone_status", error: "db_unavailable" },
         };
       }
+      const { executeMilestoneStatus } = await import("../tools/workflow-tool-executors.js");
       return executeMilestoneStatus(params);
     },
   });
@@ -55,6 +54,7 @@ export function registerQueryTools(pi: ExtensionAPI): void {
           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/src/resources/extensions/gsd/bootstrap/register-extension.ts

@@ -3,9 +3,8 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
 
 import { registerExitCommand } from "../exit-command.js";
-import { registerWorktreeCommand } from "../worktree-command.js";
+import { registerLazyWorktreeCommands } from "../worktree-command-bootstrap.js";
 import type { GSDEcosystemBeforeAgentStartHandler } from "../ecosystem/gsd-extension-api.js";
-import { loadEcosystemExtensions } from "../ecosystem/loader.js";
 import { registerDbTools } from "./db-tools.js";
 import { registerDynamicTools } from "./dynamic-tools.js";
 import { registerExecTools } from "./exec-tools.js";
@@ -71,7 +70,7 @@ function installEpipeGuard(): void {
 export function registerGsdExtension(pi: ExtensionAPI): void {
   // 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
@@ -116,12 +115,14 @@ export function registerGsdExtension(pi: ExtensionAPI): void {
     ["cmux-events", () => initCmuxEventListeners(pi.events)],
     ["hooks", () => registerHooks(pi, ecosystemHandlers)],
     ["ecosystem", () => {
-      void loadEcosystemExtensions(pi, ecosystemHandlers).catch((err) => {
-        logWarning(
-          "ecosystem",
-          `loader failed: ${err instanceof Error ? err.message : String(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/src/resources/extensions/gsd/bootstrap/register-hooks.ts

@@ -5,24 +5,16 @@ import { isToolCallEventType } from "@gsd/pi-coding-agent";
 
 import type { GSDEcosystemBeforeAgentStartHandler } from "../ecosystem/gsd-extension-api.js";
 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 { getAutoRuntimeSnapshot, isAutoActive, isAutoPaused, markToolEnd, markToolStart, recordToolInvocationError } from "../auto-runtime-state.js";
 
-import { isParallelActive, shutdownParallel } from "../parallel-orchestrator.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";
@@ -30,17 +22,46 @@ 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: string) {
+  const { deriveState } = await import("../state.js");
+  return deriveState(basePath);
+}
+
+async function getDiscussionMilestoneIdFor(basePath: string): Promise<string | null> {
+  const { getDiscussionMilestoneId } = await import("../guided-flow.js");
+  return getDiscussionMilestoneId(basePath);
+}
+
+async function loadToolApiKeysForSession(): Promise<void> {
+  const { loadToolApiKeys } = await import("../commands-config.js");
+  loadToolApiKeys();
+}
+
+async function resetAskUserQuestionsTurnCache(): Promise<void> {
+  const { resetAskUserQuestionsCache } = await import("../../ask-user-questions.js");
+  resetAskUserQuestionsCache();
+}
+
 async function syncServiceTierStatus(ctx: ExtensionContext): Promise<void> {
   const { getEffectiveServiceTier, formatServiceTierFooterStatus } = await import("../service-tier.js");
   ctx.ui.setStatus("gsd-fast", formatServiceTierFooterStatus(getEffectiveServiceTier(), ctx.model?.id));
 }
 
+async function applyDisabledModelProviderPolicy(ctx: ExtensionContext): Promise<void> {
+  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: ExtensionAPI,
   ecosystemHandlers: GSDEcosystemBeforeAgentStartHandler[],
@@ -50,12 +71,14 @@ export function registerHooks(
     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())) {
@@ -91,7 +114,7 @@ export function registerHooks(
         }
       } catch { /* non-fatal */ }
     }
-    loadToolApiKeys();
+    await loadToolApiKeysForSession();
     if (isAutoActive()) {
       ctx.ui.setWidget("gsd-health", undefined);
     }
@@ -102,9 +125,10 @@ export function registerHooks(
     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
@@ -114,23 +138,28 @@ export function registerHooks(
       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: ExtensionContext) => {
     // 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 {
       updateSnapshot(null);
@@ -169,7 +198,8 @@ export function registerHooks(
 
   pi.on("agent_end", async (event, ctx: ExtensionContext) => {
     resetToolCallLoopGuard();
-    resetAskUserQuestionsCache();
+    await resetAskUserQuestionsTurnCache();
+    const { handleAgentEnd } = await import("./agent-end-recovery.js");
     await handleAgentEnd(pi, event, ctx);
   });
 
@@ -178,6 +208,7 @@ export function registerHooks(
   // 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 {
       // Best-effort: don't break the turn lifecycle if cleanup fails.
@@ -194,8 +225,8 @@ export function registerHooks(
     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) return;
+    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)
     // that would be lost on compaction (#4258).
@@ -210,21 +241,31 @@ export function registerHooks(
     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" as const,
         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}.`,
     }));
   });
 
@@ -246,7 +287,7 @@ export function registerHooks(
       const basePath = process.cwd();
       let activeContext: string | null = 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}` +
@@ -265,6 +306,7 @@ export function registerHooks(
   });
 
   pi.on("session_shutdown", async (_event, ctx: ExtensionContext) => {
+    const { isParallelActive, shutdownParallel } = await import("../parallel-orchestrator.js");
     if (isParallelActive()) {
       try {
         await shutdownParallel(process.cwd());
@@ -273,7 +315,7 @@ export function registerHooks(
       }
     }
     if (!isAutoActive() && !isAutoPaused()) return;
-    const dash = getAutoDashboardData();
+    const dash = getAutoRuntimeSnapshot();
     if (dash.currentUnit) {
       saveActivityLog(ctx, dash.basePath, dash.currentUnit.type, dash.currentUnit.id);
     }
@@ -302,7 +344,7 @@ export function registerHooks(
     // 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,
@@ -337,6 +379,41 @@ export function registerHooks(
       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: string[] | undefined;
+        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 as { input?: unknown }).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)) {
@@ -362,7 +439,7 @@ export function registerHooks(
     const result = shouldBlockContextWrite(
       event.toolName,
       event.input.path,
-      getDiscussionMilestoneId(discussionBasePath),
+      await getDiscussionMilestoneIdFor(discussionBasePath),
       isQueuePhaseActive(),
     );
     if (result.block) return result;
@@ -374,6 +451,19 @@ export function registerHooks(
     markToolStart(event.toolCallId, event.toolName);
     safetyRecordToolCall(event.toolCallId, event.toolName, event.input as Record<string, unknown>);
 
+    // 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);
@@ -407,7 +497,7 @@ export function registerHooks(
       recordToolInvocationError(event.toolName, errorText);
     }
     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 as any;
@@ -506,7 +596,7 @@ export function registerHooks(
       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/src/resources/extensions/gsd/bootstrap/register-shortcuts.ts

@@ -4,13 +4,14 @@ import { join } from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
 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(): Promise<string> {
+  const { projectRoot } = await import("../commands/context.js");
+  return projectRoot();
+}
+
 export function registerShortcuts(pi: ExtensionAPI): void {
   const overlayOptions = {
     width: "90%",
@@ -20,7 +21,10 @@ export function registerShortcuts(pi: ExtensionAPI): void {
   } as const;
 
   const openDashboardOverlay = async (ctx: ExtensionContext) => {
-    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;
@@ -35,6 +39,7 @@ export function registerShortcuts(pi: ExtensionAPI): void {
   };
 
   const openNotificationsOverlay = async (ctx: ExtensionContext) => {
+    const { GSDNotificationOverlay } = await import("../notification-overlay.js");
     await ctx.ui.custom<boolean>(
       (tui, theme, _kb, done) => new GSDNotificationOverlay(tui, theme, () => done(true)),
       {
@@ -51,12 +56,13 @@ export function registerShortcuts(pi: ExtensionAPI): void {
   };
 
   const openParallelOverlay = async (ctx: ExtensionContext) => {
-    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<boolean>(
       (tui, theme, _kb, done) => new ParallelMonitorOverlay(tui, theme, () => done(true), basePath),
       {