gsd-pi 2.78.1-dev.84a383f51 → 2.78.1

package/src/resources/extensions/gsd/bootstrap/register-hooks.ts

@@ -5,16 +5,24 @@ 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 { 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 { 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 { 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 { getAutoRuntimeSnapshot, isAutoActive, isAutoPaused, markToolEnd, markToolStart, recordToolInvocationError } from "../auto-runtime-state.js";
+import { deriveState } from "../state.js";
+import { getAutoDashboardData, isAutoActive, isAutoPaused, markToolEnd, markToolStart, recordToolInvocationError } from "../auto.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";
@@ -22,45 +30,17 @@ 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";
 
 // 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[],
@@ -70,14 +50,12 @@ export function registerHooks(
     installNotifyInterceptor(ctx);
     initNotificationWidget(ctx);
     if (!isAutoActive()) {
-      const { initHealthWidget } = await import("../health-widget.js");
       initHealthWidget(ctx);
     }
     resetWriteGateState();
     resetToolCallLoopGuard();
-    await resetAskUserQuestionsTurnCache();
+    resetAskUserQuestionsCache();
     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())) {
@@ -113,7 +91,7 @@ export function registerHooks(
         }
       } catch { /* non-fatal */ }
     }
-    await loadToolApiKeysForSession();
+    loadToolApiKeys();
     if (isAutoActive()) {
       ctx.ui.setWidget("gsd-health", undefined);
     }
@@ -124,10 +102,9 @@ export function registerHooks(
     installNotifyInterceptor(ctx);
     resetWriteGateState();
     resetToolCallLoopGuard();
-    await resetAskUserQuestionsTurnCache();
+    resetAskUserQuestionsCache();
     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
@@ -137,28 +114,23 @@ export function registerHooks(
       const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
       prepareWorkflowMcpForProject(ctx, process.cwd());
     }
-    await loadToolApiKeysForSession();
-    if (!isAutoActive()) {
-      const { initHealthWidget } = await import("../health-widget.js");
-      initHealthWidget(ctx);
-    } else {
+    loadToolApiKeys();
+    if (isAutoActive()) {
       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 deriveGsdState(process.cwd());
+      const state = await deriveState(process.cwd());
       updateSnapshot(state);
     } catch {
       updateSnapshot(null);
@@ -197,8 +169,7 @@ export function registerHooks(
 
   pi.on("agent_end", async (event, ctx: ExtensionContext) => {
     resetToolCallLoopGuard();
-    await resetAskUserQuestionsTurnCache();
-    const { handleAgentEnd } = await import("./agent-end-recovery.js");
+    resetAskUserQuestionsCache();
     await handleAgentEnd(pi, event, ctx);
   });
 
@@ -207,7 +178,6 @@ 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.
@@ -224,8 +194,8 @@ export function registerHooks(
     const basePath = process.cwd();
     const { ensureDbOpen } = await import("./dynamic-tools.js");
     await ensureDbOpen();
-    const state = await deriveGsdState(basePath);
-    if (!state.activeMilestone || !state.activeSlice) return;
+    const state = await deriveState(basePath);
+    if (!state.activeMilestone || !state.activeSlice || !state.activeTask) 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).
@@ -240,31 +210,21 @@ 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: taskId,
+        task: state.activeTask.id,
         step: 0,
         totalSteps: 0,
         status: "compacted" as const,
         savedAt: new Date().toISOString(),
       },
-      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.",
+      completedWork: `Task ${state.activeTask.id} (${state.activeTask.title}) was in progress when compaction occurred.`,
+      remainingWork: "Check the task plan for remaining steps.",
       decisions: "Check task summary files for prior decisions.",
       context: "Session was auto-compacted by Pi. Resume with /gsd.",
-      nextAction: state.activeTask
-        ? `Resume task ${taskId}: ${taskTitle}.`
-        : `Resume ${phaseLabel} work for slice ${state.activeSlice.id}.`,
+      nextAction: `Resume task ${state.activeTask.id}: ${state.activeTask.title}.`,
     }));
   });
 
@@ -286,7 +246,7 @@ export function registerHooks(
       const basePath = process.cwd();
       let activeContext: string | null = null;
       try {
-        const state = await deriveGsdState(basePath);
+        const state = await deriveState(basePath);
         if (state.activeMilestone && state.activeSlice && state.activeTask) {
           activeContext =
             `Active: ${state.activeMilestone.id} / ${state.activeSlice.id} / ${state.activeTask.id}` +
@@ -305,7 +265,6 @@ 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());
@@ -314,7 +273,7 @@ export function registerHooks(
       }
     }
     if (!isAutoActive() && !isAutoPaused()) return;
-    const dash = getAutoRuntimeSnapshot();
+    const dash = getAutoDashboardData();
     if (dash.currentUnit) {
       saveActivityLog(ctx, dash.basePath, dash.currentUnit.type, dash.currentUnit.id);
     }
@@ -343,7 +302,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 = await getDiscussionMilestoneIdFor(discussionBasePath);
+      const milestoneId = getDiscussionMilestoneId(discussionBasePath);
       if (isToolCallEventType("bash", event)) {
         const bashGuard = shouldBlockPendingGateBash(
           event.input.command,
@@ -378,36 +337,6 @@ 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 = "";
-        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;
-        }
-        const planningGuard = shouldBlockPlanningUnit(
-          event.toolName,
-          planningInput,
-          dash.basePath || discussionBasePath,
-          activeUnitType,
-          manifest.tools,
-        );
-        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)) {
@@ -433,7 +362,7 @@ export function registerHooks(
     const result = shouldBlockContextWrite(
       event.toolName,
       event.input.path,
-      await getDiscussionMilestoneIdFor(discussionBasePath),
+      getDiscussionMilestoneId(discussionBasePath),
       isQueuePhaseActive(),
     );
     if (result.block) return result;
@@ -478,7 +407,7 @@ export function registerHooks(
       recordToolInvocationError(event.toolName, errorText);
     }
     if (event.toolName !== "ask_user_questions") return;
-    const milestoneId = await getDiscussionMilestoneIdFor(process.cwd());
+    const milestoneId = getDiscussionMilestoneId(process.cwd());
     const queueActive = isQueuePhaseActive();
 
     const details = event.details as any;
@@ -577,7 +506,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 = getAutoRuntimeSnapshot();
+      const dash = getAutoDashboardData();
       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,14 +4,13 @@ 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%",
@@ -21,10 +20,7 @@ export function registerShortcuts(pi: ExtensionAPI): void {
   } as const;
 
   const openDashboardOverlay = async (ctx: ExtensionContext) => {
-    const [{ GSDDashboardOverlay }, basePath] = await Promise.all([
-      import("../dashboard-overlay.js"),
-      getProjectRoot(),
-    ]);
+    const basePath = projectRoot();
     if (!existsSync(join(basePath, ".gsd"))) {
       ctx.ui.notify("No .gsd/ directory found. Run /gsd to start.", "info");
       return;
@@ -39,7 +35,6 @@ 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)),
       {
@@ -56,13 +51,12 @@ export function registerShortcuts(pi: ExtensionAPI): void {
   };
 
   const openParallelOverlay = async (ctx: ExtensionContext) => {
-    const basePath = await getProjectRoot();
+    const basePath = projectRoot();
     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),
       {

package/src/resources/extensions/gsd/bootstrap/system-context.ts

@@ -15,7 +15,7 @@ import { resolveGsdRootFile, resolveSliceFile, resolveSlicePath, resolveTaskFile
 import { ensureCodebaseMapFresh, readCodebaseMap } from "../codebase-generator.js";
 import { hasSkillSnapshot, detectNewSkills, formatSkillsXml } from "../skill-discovery.js";
 import { getActiveAutoWorktreeContext } from "../auto-worktree.js";
-import { getActiveWorktreeName, getWorktreeOriginalCwd } from "../worktree-session-state.js";
+import { getActiveWorktreeName, getWorktreeOriginalCwd } from "../worktree-command.js";
 import { deriveState } from "../state.js";
 import { formatOverridesSection, formatShortcut, loadActiveOverrides, loadFile, parseContinue, parseSummary } from "../files.js";
 import { toPosixPath } from "../../shared/mod.js";
@@ -207,14 +207,7 @@ export async function buildBeforeAgentStartResult(
     ? `\n\n## Subagent Model\n\nWhen spawning subagents via the \`subagent\` tool, always pass \`model: "${subagentModelConfig.primary}"\` in the tool call parameters. Never omit this — always specify it explicitly.`
     : "";
 
-  // memoryBlock is FTS-queried against the user prompt and changes per call.
-  // Removing it from `fullSystem` keeps the system-prompt cache breakpoint
-  // stable across calls — the only scoped goal of this fix. The pi-ai
-  // Anthropic adapter additionally cache-marks the last user turn, so the
-  // memoryBlock injected via the context message may itself be cached up to
-  // that boundary; that's orthogonal and unchanged from prior behavior. The
-  // load-bearing win here is preserving the system+tools cache hit. (#5019)
-  const fullSystem = `${event.systemPrompt}\n\n[SYSTEM CONTEXT — GSD]\n\n${systemContent}${preferenceBlock}${knowledgeBlock}${codebaseBlock}${newSkillsBlock}${worktreeBlock}${subagentModelBlock}`;
+  const fullSystem = `${event.systemPrompt}\n\n[SYSTEM CONTEXT — GSD]\n\n${systemContent}${preferenceBlock}${knowledgeBlock}${codebaseBlock}${memoryBlock}${newSkillsBlock}${worktreeBlock}${subagentModelBlock}`;
 
   stopContextTimer({
     systemPromptSize: fullSystem.length,
@@ -223,7 +216,12 @@ export async function buildBeforeAgentStartResult(
     hasNewSkills: newSkillsBlock.length > 0,
   });
 
-  const contextMessage = buildContextMessage({ memoryBlock, injection, forensicsInjection });
+  // Determine which context message to inject (guided execute takes priority)
+  const contextMessage = injection
+    ? { customType: "gsd-guided-context", content: injection, display: false as const }
+    : forensicsInjection
+      ? { customType: "gsd-forensics", content: forensicsInjection, display: false as const }
+      : null;
 
   return {
     systemPrompt: fullSystem,
@@ -231,35 +229,6 @@ export async function buildBeforeAgentStartResult(
   };
 }
 
-/**
- * Route the per-call dynamic blocks (memory, guided-execute, forensics) into a
- * single user-message context payload so they ride the volatile suffix instead
- * of the cached system prefix. Priority when both memory and an injection are
- * present: guided > forensics > memory-only. (#5019)
- *
- * Exported for direct unit testing — the surrounding bootstrap has too many
- * filesystem and DB dependencies to exercise this routing logic in-place.
- */
-export function buildContextMessage(opts: {
-  memoryBlock: string;
-  injection: string | null;
-  forensicsInjection: string | null;
-}): { customType: string; content: string; display: false } | null {
-  const memoryContent = opts.memoryBlock.trim();
-  if (opts.injection) {
-    const content = memoryContent ? `${memoryContent}\n\n${opts.injection}` : opts.injection;
-    return { customType: "gsd-guided-context", content, display: false as const };
-  }
-  if (opts.forensicsInjection) {
-    const content = memoryContent ? `${memoryContent}\n\n${opts.forensicsInjection}` : opts.forensicsInjection;
-    return { customType: "gsd-forensics", content, display: false as const };
-  }
-  if (memoryContent) {
-    return { customType: "gsd-memory", content: memoryContent, display: false as const };
-  }
-  return null;
-}
-
 /**
  * ADR-013 step 4 — auto-injection parity for the memories table.
  *

package/src/resources/extensions/gsd/bootstrap/write-gate.ts

@@ -3,7 +3,15 @@ import { isAbsolute, join, relative, resolve, sep } from "node:path";
 
 import { minimatch } from "minimatch";
 
-import type { ToolsPolicy } from "../unit-context-manifest.js";
+/**
+ * Declarative tools-policy for a unit. Inlined here because the worktree
+ * branch predates the full unit-context-manifest export (#4934).
+ */
+export type ToolsPolicy =
+  | { mode: "all" }
+  | { mode: "read-only" }
+  | { mode: "planning" }
+  | { mode: "docs"; allowedPathGlobs: readonly string[] };
 
 /**
  * Regex matching milestone CONTEXT.md file names in both legacy M001
@@ -527,33 +535,10 @@ export function shouldBlockQueueExecutionInSnapshot(
 }
 
 // ─── Planning-unit tools-policy enforcement (#4934) ───────────────────────
-//
-// Runtime half of the declarative ToolsPolicy on UnitContextManifest. The
-// manifest assigns each unit type a tools mode; this predicate is what
-// actually rejects a tool call that violates it.
-//
-// Forensics: a discuss-milestone LLM turn used the host Edit tool to modify
-// index.html in test app b23 (~/Github/test-apps/b23). With this predicate
-// wired into the tool_call hook, the same call returns block=true with a
-// HARD BLOCK reason that the model cannot rationalize past.
-//
-// Activation: the hook supplies the policy resolved from the active unit's
-// manifest. When no unit is active (interactive sessions, unknown unit
-// types), the hook passes null and this predicate is a no-op — falling
-// through to the existing pendingGate / queue-execution / context-write
-// guards.
 
 const PLANNING_WRITE_TOOLS = new Set(["write", "edit", "multi_edit", "notebook_edit"]);
 const PLANNING_SUBAGENT_TOOLS = new Set(["subagent", "task"]);
 
-/**
- * Read-only / planning-safe tools that any non-"all" mode allows. Mirrors
- * QUEUE_SAFE_TOOLS / GATE_SAFE_TOOLS but is the inclusive default for
- * planning units (which need their full discussion + research surface).
- *
- * gsd_* MCP tools are passed through unconditionally — they have their own
- * domain validation (e.g. depth-verification gate, single-writer DB).
- */
 const PLANNING_SAFE_TOOLS = new Set([
   "read", "grep", "find", "ls", "glob",
   "ask_user_questions",
@@ -570,7 +555,6 @@ function isPathUnderGsd(absPath: string, basePath: string): boolean {
 function matchesAllowedGlob(absPath: string, basePath: string, globs: readonly string[]): boolean {
   const rel = relative(basePath, absPath);
   if (rel.startsWith("..") || isAbsolute(rel)) return false;
-  // Normalize Windows separators for minimatch.
   const posix = rel.split(sep).join("/");
   return globs.some(g => minimatch(posix, g, { dot: false, nocase: false }));
 }
@@ -595,12 +579,7 @@ function blockReason(unitType: string, mode: string, what: string): string {
  *   - "docs"       → like "planning" but also allows writes to paths
  *                    matching `allowedPathGlobs` relative to basePath.
  *
- * `pathOrCommand` is the file path for write/edit-shaped tools and the
- * shell command for bash. Other tools ignore this argument.
- *
- * `policy` of null means "no manifest resolved" — pass-through. Callers
- * that have no active unit (interactive sessions) pass null and this
- * predicate is a no-op.
+ * `policy` of null means "no manifest resolved" — pass-through.
  */
 export function shouldBlockPlanningUnit(
   toolName: string,
@@ -614,18 +593,16 @@ export function shouldBlockPlanningUnit(
 
   const tool = toolName;
 
-  // Read-only mode: only Read-class tools are permitted.
   if (policy.mode === "read-only") {
     if (PLANNING_SAFE_TOOLS.has(tool)) return { block: false };
     if (tool.startsWith("gsd_")) return { block: false };
     if (PLANNING_WRITE_TOOLS.has(tool) || tool === "bash" || PLANNING_SUBAGENT_TOOLS.has(tool)) {
       return { block: true, reason: blockReason(unitType, policy.mode, `${tool} is not permitted (read-only)`) };
     }
-    // Unknown tool in read-only mode — block by default.
     return { block: true, reason: blockReason(unitType, policy.mode, `tool "${tool}" is not on the read-only allowlist`) };
   }
 
-  // planning / docs modes share the same surface for safe tools, bash, and subagent.
+  // planning / docs modes
   if (PLANNING_SAFE_TOOLS.has(tool)) return { block: false };
   if (tool.startsWith("gsd_")) return { block: false };
 
@@ -651,10 +628,8 @@ export function shouldBlockPlanningUnit(
     }
     const absPath = isAbsolute(pathOrCommand) ? pathOrCommand : resolve(basePath, pathOrCommand);
 
-    // Always allow .gsd/ writes — that's where planning artifacts live.
     if (isPathUnderGsd(absPath, basePath)) return { block: false };
 
-    // docs mode additionally allows the manifest's allowedPathGlobs.
     if (policy.mode === "docs" && matchesAllowedGlob(absPath, basePath, policy.allowedPathGlobs)) {
       return { block: false };
     }
@@ -669,8 +644,5 @@ export function shouldBlockPlanningUnit(
     };
   }
 
-  // Unknown tool name — pass through. Other layers (queue, pending-gate,
-  // CONTEXT.md write) catch known mutating shapes; defaulting to allow here
-  // avoids breaking gsd_* MCP tools or future safe additions.
   return { block: false };
 }

package/src/resources/extensions/gsd/commands/catalog.ts

@@ -1,8 +1,9 @@
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { join } from "node:path";
 
 import { loadRegistry } from "../workflow-templates.js";
+import { resolveProjectRoot } from "../worktree.js";
 
 const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
 
@@ -14,7 +15,7 @@ export interface GsdCommandDefinition {
 type CompletionMap = Record<string, readonly GsdCommandDefinition[]>;
 
 export const GSD_COMMAND_DESCRIPTION =
-  "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|queue|quick|discuss|capture|triage|dispatch|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|model|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|debug|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|onboarding|inspect|extensions|update|fast|mcp|rethink|workflow|codebase|notifications|ship|do|session-report|backlog|pr-branch|add-tests|scan|language";
+  "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|queue|quick|discuss|capture|triage|dispatch|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|model|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|debug|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|onboarding|inspect|extensions|update|fast|mcp|rethink|codebase|notifications|ship|do|session-report|backlog|pr-branch|add-tests|scan|language";
 
 export const TOP_LEVEL_SUBCOMMANDS: readonly GsdCommandDefinition[] = [
   { cmd: "help", desc: "Categorized command reference with descriptions" },
@@ -345,77 +346,6 @@ function getExtensionCompletions(prefix: string, action: string) {
   }
 }
 
-function normalizePathForCompare(path: string): string {
-  return path.replaceAll("\\", "/").replace(/\/+$/, "");
-}
-
-function findWorktreeSegment(normalizedPath: string): { gsdIdx: number; afterWorktrees: number } | null {
-  const directMarker = "/.gsd/worktrees/";
-  const directIdx = normalizedPath.indexOf(directMarker);
-  if (directIdx !== -1) {
-    return { gsdIdx: directIdx, afterWorktrees: directIdx + directMarker.length };
-  }
-
-  const symlinkMatch = normalizedPath.match(/\/\.gsd\/projects\/[a-f0-9]+\/worktrees\//);
-  if (symlinkMatch?.index !== undefined) {
-    return { gsdIdx: symlinkMatch.index, afterWorktrees: symlinkMatch.index + symlinkMatch[0].length };
-  }
-
-  return null;
-}
-
-function resolveProjectRootFromGitFile(worktreePath: string): string | null {
-  try {
-    let dir = worktreePath;
-    for (let i = 0; i < 30; i++) {
-      const gitPath = join(dir, ".git");
-      if (existsSync(gitPath)) {
-        const content = readFileSync(gitPath, "utf8").trim();
-        if (content.startsWith("gitdir: ")) {
-          const gitDir = resolve(dir, content.slice(8));
-          const dotGitDir = resolve(gitDir, "..", "..");
-          if (dotGitDir.endsWith(".git") || dotGitDir.endsWith(".git/") || dotGitDir.endsWith(".git\\")) {
-            return resolve(dotGitDir, "..");
-          }
-          const commonDirPath = join(gitDir, "commondir");
-          if (existsSync(commonDirPath)) {
-            const commonDir = readFileSync(commonDirPath, "utf8").trim();
-            return resolve(resolve(gitDir, commonDir), "..");
-          }
-        }
-        break;
-      }
-      const parent = resolve(dir, "..");
-      if (parent === dir) break;
-      dir = parent;
-    }
-  } catch {
-    // Completion must stay best-effort.
-  }
-  return null;
-}
-
-function resolveProjectRootForCompletion(basePath: string): string {
-  if (process.env.GSD_PROJECT_ROOT) return process.env.GSD_PROJECT_ROOT;
-
-  const normalizedPath = normalizePathForCompare(basePath);
-  const segment = findWorktreeSegment(normalizedPath);
-  if (!segment) return basePath;
-
-  const separator = basePath.includes("\\") ? "\\" : "/";
-  const gsdMarker = `${separator}.gsd${separator}`;
-  const gsdIdx = basePath.indexOf(gsdMarker);
-  const candidate = gsdIdx !== -1 ? basePath.slice(0, gsdIdx) : basePath.slice(0, segment.gsdIdx);
-
-  const normalizedGsdHome = normalizePathForCompare(gsdHome);
-  const candidateGsdPath = normalizePathForCompare(join(candidate, ".gsd"));
-  if (candidateGsdPath === normalizedGsdHome || candidateGsdPath.startsWith(`${normalizedGsdHome}/`)) {
-    return resolveProjectRootFromGitFile(basePath) ?? basePath;
-  }
-
-  return candidate;
-}
-
 export function getGsdArgumentCompletions(prefix: string) {
   const hasTrailingSpace = prefix.endsWith(" ");
   const parts = prefix.trim().split(/\s+/);
@@ -476,7 +406,7 @@ export function getGsdArgumentCompletions(prefix: string) {
   // Workflow definition-name completion for `workflow run <name>` and `workflow validate <name>`
   if (command === "workflow" && (subcommand === "run" || subcommand === "validate") && parts.length <= 3) {
     try {
-      const defsDir = join(resolveProjectRootForCompletion(process.cwd()), ".gsd", "workflow-defs");
+      const defsDir = join(resolveProjectRoot(process.cwd()), ".gsd", "workflow-defs");
       if (existsSync(defsDir)) {
         return readdirSync(defsDir)
           .filter((f) => f.endsWith(".yaml") && f.startsWith(third))
@@ -513,7 +443,7 @@ export function getGsdArgumentCompletions(prefix: string) {
       } catch { /* ignore */ }
     };
     try {
-      const base = resolveProjectRootForCompletion(process.cwd());
+      const base = resolveProjectRoot(process.cwd());
       scanDir(join(base, ".gsd", "workflows"), "project");
       scanDir(join(base, ".gsd", "workflow-defs"), "project-legacy");
       scanDir(join(gsdHome, "workflows"), "global");