gsd-pi 2.33.1 → 2.34.0-dev.bbb5216

package/src/resources/extensions/gsd/guided-flow.ts

@@ -792,17 +792,28 @@ export async function showSmartEntry(
   const crashLock = readCrashLock(basePath);
   if (crashLock) {
     clearLock(basePath);
-    const resume = await showNextAction(ctx, {
-      title: "GSD — Interrupted Session Detected",
-      summary: [formatCrashInfo(crashLock)],
-      actions: [
-        { id: "resume", label: "Resume with /gsd auto", description: "Pick up where it left off", recommended: true },
-        { id: "continue", label: "Continue manually", description: "Open the wizard as normal" },
-      ],
-    });
-    if (resume === "resume") {
-      await startAuto(ctx, pi, basePath, false);
-      return;
+
+    // Bootstrap crash with zero completed units = no work was lost.
+    // Auto-discard instead of prompting the user — this commonly happens
+    // when the user exits during init wizard or discuss phase before any
+    // real auto-mode work begins.
+    const isBootstrapCrash = crashLock.unitType === "starting"
+      && crashLock.unitId === "bootstrap"
+      && crashLock.completedUnits === 0;
+
+    if (!isBootstrapCrash) {
+      const resume = await showNextAction(ctx, {
+        title: "GSD — Interrupted Session Detected",
+        summary: [formatCrashInfo(crashLock)],
+        actions: [
+          { id: "resume", label: "Resume with /gsd auto", description: "Pick up where it left off", recommended: true },
+          { id: "continue", label: "Continue manually", description: "Open the wizard as normal" },
+        ],
+      });
+      if (resume === "resume") {
+        await startAuto(ctx, pi, basePath, false);
+        return;
+      }
     }
   }
 

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

@@ -35,7 +35,8 @@ import { getActiveAutoWorktreeContext } from "./auto-worktree.js";
 import { saveFile, formatContinue, loadFile, parseContinue, parseSummary, loadActiveOverrides, formatOverridesSection } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { deriveState } from "./state.js";
-import { isAutoActive, isAutoPaused, handleAgentEnd, pauseAuto, getAutoDashboardData, getAutoModeStartModel, markToolStart, markToolEnd } from "./auto.js";
+import { isAutoActive, isAutoPaused, pauseAuto, getAutoDashboardData, getAutoModeStartModel, markToolStart, markToolEnd } from "./auto.js";
+import { isSessionSwitchInFlight, resolveAgentEnd } from "./auto-loop.js";
 import { saveActivityLog } from "./activity-log.js";
 import { checkAutoStartAfterDiscuss, getDiscussionMilestoneId, findMilestoneIds, nextMilestoneId } from "./guided-flow.js";
 import { GSDDashboardOverlay } from "./dashboard-overlay.js";
@@ -64,26 +65,6 @@ import { pauseAutoForProviderError, classifyProviderError } from "./provider-err
 import { toPosixPath } from "../shared/mod.js";
 import { isParallelActive, shutdownParallel } from "./parallel-orchestrator.js";
 import { DEFAULT_BASH_TIMEOUT_SECS } from "./constants.js";
-import { getErrorMessage } from "./error-utils.js";
-
-/**
- * Ensure the GSD database is available, auto-initializing if needed.
- * Returns true if the DB is ready, false if initialization failed.
- */
-async function ensureDbAvailable(): Promise<boolean> {
-  try {
-    const db = await import("./gsd-db.js");
-    if (db.isDbAvailable()) return true;
-
-    // Auto-initialize: open (and create if needed) the DB at the standard path
-    const gsdDir = gsdRoot(process.cwd());
-    if (!existsSync(gsdDir)) return false; // No GSD project — can't create DB
-    const dbPath = join(gsdDir, "gsd.db");
-    return db.openDatabase(dbPath);
-  } catch {
-    return false;
-  }
-}
 
 // ── Agent Instructions ────────────────────────────────────────────────────
 // Lightweight "always follow" files injected into every GSD agent session.
@@ -114,9 +95,7 @@ function loadAgentInstructions(): string | null {
 }
 
 // ── Depth verification state ──────────────────────────────────────────────
-// Tracks which milestones have passed depth verification.
-// Single-milestone flows set '*' (wildcard). Multi-milestone flows set per-ID.
-const depthVerifiedMilestones = new Set<string>();
+let depthVerificationDone = false;
 
 // ── Queue phase tracking ──────────────────────────────────────────────────
 // When true, the LLM is in a queue flow writing CONTEXT.md files.
@@ -127,28 +106,11 @@ let activeQueuePhase = false;
 // Tracks per-model retry attempts for transient network errors.
 // Cleared when a model switch occurs or retries are exhausted.
 const networkRetryCounters = new Map<string, number>();
-
-// ── Transient error escalation ───────────────────────────────────────────
-// Tracks consecutive transient auto-resume attempts. Each attempt doubles
-// the delay. After MAX_TRANSIENT_AUTO_RESUMES consecutive failures, auto-mode
-// pauses indefinitely to avoid infinite rapid-fire retries (#1166).
-const MAX_TRANSIENT_AUTO_RESUMES = 5;
+const MAX_TRANSIENT_AUTO_RESUMES = 3;
 let consecutiveTransientErrors = 0;
 
 export function isDepthVerified(): boolean {
-  return depthVerifiedMilestones.has("*") || depthVerifiedMilestones.size > 0;
-}
-
-/** Check whether a specific milestone has passed depth verification. */
-export function isDepthVerifiedFor(milestoneId: string): boolean {
-  // Wildcard means "all milestones verified" (single-milestone flow)
-  if (depthVerifiedMilestones.has("*")) return true;
-  return depthVerifiedMilestones.has(milestoneId);
-}
-
-/** Mark a specific milestone as depth-verified. */
-export function markDepthVerified(milestoneId: string): void {
-  depthVerifiedMilestones.add(milestoneId);
+  return depthVerificationDone;
 }
 
 /** Check whether a queue phase is active. */
@@ -179,25 +141,11 @@ export function shouldBlockContextWrite(
   if (!inDiscussion && !inQueue) return { block: false };
 
   if (!MILESTONE_CONTEXT_RE.test(inputPath)) return { block: false };
-
-  // For discussion flows: check global depth verification (backward compat)
-  if (inDiscussion && depthVerified) return { block: false };
-
-  // For queue flows: extract milestone ID from the path and check per-milestone verification
-  if (inQueue) {
-    const pathMatch = inputPath.match(/\/(M\d+(?:-[a-z0-9]{6})?)-CONTEXT\.md$/);
-    const targetMid = pathMatch?.[1];
-    if (targetMid && depthVerifiedMilestones.has(targetMid)) return { block: false };
-    // Wildcard passes all
-    if (depthVerifiedMilestones.has("*")) return { block: false };
-  }
+  if (depthVerified) return { block: false };
 
   return {
     block: true,
-    reason: `Blocked: Cannot write milestone CONTEXT.md without depth verification. ` +
-      `Use ask_user_questions with a question id containing "depth_verification" first. ` +
-      `For multi-milestone flows, include the milestone ID in the question id (e.g., "depth_verification_M001"). ` +
-      `This ensures each milestone's context has been critically examined before being written.`,
+    reason: `Blocked: Cannot write to milestone CONTEXT.md during discussion phase without depth verification. Call ask_user_questions with question id "depth_verification" first to confirm discussion depth before writing context.`,
   };
 }
 
@@ -348,8 +296,14 @@ export default function (pi: ExtensionAPI) {
       when_context: Type.Optional(Type.String({ description: "When/context for the decision (e.g. milestone ID)" })),
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-      // Ensure DB is available (auto-initialize if needed)
-      if (!await ensureDbAvailable()) {
+      // Check DB availability
+      let dbAvailable = false;
+      try {
+        const db = await import("./gsd-db.js");
+        dbAvailable = db.isDbAvailable();
+      } catch { /* dynamic import failed */ }
+
+      if (!dbAvailable) {
         return {
           content: [{ type: "text" as const, text: "Error: GSD database is not available. Cannot save decision." }],
           isError: true,
@@ -375,7 +329,7 @@ export default function (pi: ExtensionAPI) {
           details: { operation: "save_decision", id },
         };
       } catch (err) {
-        const msg = getErrorMessage(err);
+        const msg = err instanceof Error ? err.message : String(err);
         process.stderr.write(`gsd-db: gsd_save_decision tool failed: ${msg}\n`);
         return {
           content: [{ type: "text" as const, text: `Error saving decision: ${msg}` }],
@@ -409,8 +363,13 @@ export default function (pi: ExtensionAPI) {
       supporting_slices: Type.Optional(Type.String({ description: "Supporting slices" })),
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-      // Ensure DB is available (auto-initialize if needed)
-      if (!await ensureDbAvailable()) {
+      let dbAvailable = false;
+      try {
+        const db = await import("./gsd-db.js");
+        dbAvailable = db.isDbAvailable();
+      } catch { /* dynamic import failed */ }
+
+      if (!dbAvailable) {
         return {
           content: [{ type: "text" as const, text: "Error: GSD database is not available. Cannot update requirement." }],
           isError: true,
@@ -446,7 +405,7 @@ export default function (pi: ExtensionAPI) {
           details: { operation: "update_requirement", id: params.id },
         };
       } catch (err) {
-        const msg = getErrorMessage(err);
+        const msg = err instanceof Error ? err.message : String(err);
         process.stderr.write(`gsd-db: gsd_update_requirement tool failed: ${msg}\n`);
         return {
           content: [{ type: "text" as const, text: `Error updating requirement: ${msg}` }],
@@ -478,8 +437,13 @@ export default function (pi: ExtensionAPI) {
       content: Type.String({ description: "The full markdown content of the artifact" }),
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-      // Ensure DB is available (auto-initialize if needed)
-      if (!await ensureDbAvailable()) {
+      let dbAvailable = false;
+      try {
+        const db = await import("./gsd-db.js");
+        dbAvailable = db.isDbAvailable();
+      } catch { /* dynamic import failed */ }
+
+      if (!dbAvailable) {
         return {
           content: [{ type: "text" as const, text: "Error: GSD database is not available. Cannot save artifact." }],
           isError: true,
@@ -526,7 +490,7 @@ export default function (pi: ExtensionAPI) {
           details: { operation: "save_summary", path: relativePath, artifact_type: params.artifact_type },
         };
       } catch (err) {
-        const msg = getErrorMessage(err);
+        const msg = err instanceof Error ? err.message : String(err);
         process.stderr.write(`gsd-db: gsd_save_summary tool failed: ${msg}\n`);
         return {
           content: [{ type: "text" as const, text: `Error saving artifact: ${msg}` }],
@@ -575,7 +539,7 @@ export default function (pi: ExtensionAPI) {
           details: { operation: "generate_milestone_id", id: newId, existingCount: existingIds.length, reservedCount: reservedMilestoneIds.size, uniqueEnabled },
         };
       } catch (err) {
-        const msg = getErrorMessage(err);
+        const msg = err instanceof Error ? err.message : String(err);
         return {
           content: [{ type: "text" as const, text: `Error generating milestone ID: ${msg}` }],
           isError: true,
@@ -587,9 +551,8 @@ export default function (pi: ExtensionAPI) {
 
   // ── session_start: render branded GSD header + load tool keys + remote status ──
   pi.on("session_start", async (_event, ctx) => {
-    // Clear depth verification and queue phase state from any prior session
-    depthVerifiedMilestones.clear();
-    activeQueuePhase = false;
+    // Clear per-session state that must not leak across sessions (e.g. RPC mode)
+    depthVerificationDone = false;
 
     // Theme access throws in RPC mode (no TUI) — header is decorative, skip it
     try {
@@ -608,12 +571,6 @@ export default function (pi: ExtensionAPI) {
     // Load tool API keys from auth.json into environment
     loadToolApiKeys();
 
-    // Always-on health widget — ambient system health signal below the editor
-    try {
-      const { initHealthWidget } = await import("./health-widget.js");
-      initHealthWidget(ctx);
-    } catch { /* non-fatal — widget is best-effort */ }
-
     // Notify remote questions status if configured
     try {
       const [{ getRemoteConfigStatus }, { getLatestPromptSummary }] = await Promise.all([
@@ -636,12 +593,12 @@ export default function (pi: ExtensionAPI) {
     description: shortcutDesc("Open GSD dashboard", "/gsd status"),
     handler: async (ctx) => {
       // Only show if .gsd/ exists
-      if (!existsSync(gsdRoot(process.cwd()))) {
+      if (!existsSync(join(process.cwd(), ".gsd"))) {
         ctx.ui.notify("No .gsd/ directory found. Run /gsd to start.", "info");
         return;
       }
 
-      const result = await ctx.ui.custom<void>(
+      await ctx.ui.custom<void>(
         (tui, theme, _kb, done) => {
           return new GSDDashboardOverlay(tui, theme, () => done());
         },
@@ -655,18 +612,12 @@ export default function (pi: ExtensionAPI) {
           },
         },
       );
-
-      // Fallback for RPC mode where ctx.ui.custom() returns undefined.
-      if (result === undefined) {
-        const { fireStatusViaCommand } = await import("./commands.js");
-        await fireStatusViaCommand(ctx);
-      }
     },
   });
 
   // ── before_agent_start: inject GSD contract into true system prompt ─────
   pi.on("before_agent_start", async (event, ctx: ExtensionContext) => {
-    if (!existsSync(gsdRoot(process.cwd()))) return;
+    if (!existsSync(join(process.cwd(), ".gsd"))) return;
 
     const stopContextTimer = debugTime("context-inject");
     const systemContent = loadPrompt("system");
@@ -796,15 +747,9 @@ export default function (pi: ExtensionAPI) {
 
   // ── agent_end: auto-mode advancement or auto-start after discuss ───────────
   pi.on("agent_end", async (event, ctx: ExtensionContext) => {
-    // Clean up quick-task branch if one just completed (#1269)
-    try {
-      const { cleanupQuickBranch } = await import("./quick.js");
-      cleanupQuickBranch();
-    } catch { /* non-fatal */ }
-
     // If discuss phase just finished, start auto-mode
     if (checkAutoStartAfterDiscuss()) {
-      depthVerifiedMilestones.clear();
+      depthVerificationDone = false;
       activeQueuePhase = false;
       return;
     }
@@ -812,6 +757,13 @@ export default function (pi: ExtensionAPI) {
     // If auto-mode is already running, advance to next unit
     if (!isAutoActive()) return;
 
+    // Fresh-session auto-mode intentionally aborts the previous session during
+    // cmdCtx.newSession(). Ignore that agent_end so we neither pause nor
+    // resolve the new unit with an event from the old session.
+    if (isSessionSwitchInFlight()) {
+      return;
+    }
+
     // If the agent was aborted (user pressed Escape) or hit a provider
     // error (fetch failure, rate limit, etc.), pause auto-mode instead of
     // advancing. This preserves the conversation so the user can inspect
@@ -951,50 +903,46 @@ export default function (pi: ExtensionAPI) {
       const explicitRetryAfterMs = ("retryAfterMs" in lastMsg && typeof lastMsg.retryAfterMs === "number")
         ? lastMsg.retryAfterMs
         : undefined;
-      let retryAfterMs = explicitRetryAfterMs ?? classification.suggestedDelayMs;
-
-      // ── Escalating backoff for repeated transient errors ──────────────
-      // Each consecutive transient auto-resume doubles the delay. After
-      // MAX_TRANSIENT_AUTO_RESUMES consecutive failures, treat as permanent
-      // to avoid infinite rapid-fire retries (#1166).
-      let effectiveTransient = classification.isTransient;
       if (classification.isTransient) {
-        consecutiveTransientErrors++;
-        if (consecutiveTransientErrors > MAX_TRANSIENT_AUTO_RESUMES) {
-          effectiveTransient = false;
-          ctx.ui.notify(
-            `${consecutiveTransientErrors} consecutive transient errors. Pausing indefinitely — resume manually with /gsd auto.`,
-            "error",
-          );
-          consecutiveTransientErrors = 0;
-        } else {
-          // Escalate: base delay × 2^(consecutive-1) → 30s, 60s, 120s, 240s, 480s
-          retryAfterMs = retryAfterMs * 2 ** (consecutiveTransientErrors - 1);
-        }
+        consecutiveTransientErrors += 1;
+      } else {
+        consecutiveTransientErrors = 0;
+      }
+      const baseRetryAfterMs = explicitRetryAfterMs ?? classification.suggestedDelayMs;
+      const retryAfterMs = classification.isTransient ? baseRetryAfterMs * 2 ** Math.max(0, consecutiveTransientErrors - 1) : baseRetryAfterMs;
+      const allowAutoResume = classification.isTransient
+        && consecutiveTransientErrors <= MAX_TRANSIENT_AUTO_RESUMES;
+
+      if (classification.isTransient && !allowAutoResume) {
+        ctx.ui.notify(
+          `Transient provider errors persisted after ${MAX_TRANSIENT_AUTO_RESUMES} auto-resume attempts. Pausing for manual review.`,
+          "warning",
+        );
       }
 
       await pauseAutoForProviderError(ctx.ui, errorDetail, () => pauseAuto(ctx, pi), {
         isRateLimit: classification.isRateLimit,
-        isTransient: effectiveTransient,
+        isTransient: allowAutoResume,
         retryAfterMs,
-        resume: () => {
-          pi.sendMessage(
-            { customType: "gsd-auto-timeout-recovery", content: "Continue execution \u2014 provider error recovery delay elapsed.", display: false },
-            { triggerTurn: true },
-          );
-        },
+        resume: allowAutoResume
+          ? () => {
+            pi.sendMessage(
+              { customType: "gsd-auto-timeout-recovery", content: "Continue execution \u2014 provider error recovery delay elapsed.", display: false },
+              { triggerTurn: true },
+            );
+          }
+          : undefined,
       });
       return;
     }
 
     try {
+      consecutiveTransientErrors = 0;
       networkRetryCounters.clear(); // Clear network retry state on successful unit completion
-      consecutiveTransientErrors = 0; // Reset escalating backoff on success
-      await handleAgentEnd(ctx, pi);
+      resolveAgentEnd(event);
     } catch (err) {
-      // Safety net: if handleAgentEnd throws despite its internal try-catch,
-      // ensure auto-mode stops gracefully instead of silently stalling (#381).
-      const message = getErrorMessage(err);
+      // Safety net: if resolveAgentEnd throws, ensure auto-mode stops gracefully (#381).
+      const message = err instanceof Error ? err.message : String(err);
       ctx.ui.notify(
         `Auto-mode error in agent_end handler: ${message}. Stopping auto-mode.`,
         "error",
@@ -1061,19 +1009,6 @@ export default function (pi: ExtensionAPI) {
       } catch { /* best-effort */ }
     }
 
-    // Auto-commit dirty work in CLI-spawned worktrees so nothing is lost.
-    // The CLI sets GSD_CLI_WORKTREE when launched with -w.
-    const cliWorktree = process.env.GSD_CLI_WORKTREE;
-    if (cliWorktree) {
-      try {
-        const { autoCommitCurrentBranch } = await import("./worktree.js");
-        const msg = autoCommitCurrentBranch(process.cwd(), "session-end", cliWorktree);
-        if (msg) {
-          ctx.ui.notify(`Auto-committed worktree ${cliWorktree} before exit.`, "info");
-        }
-      } catch { /* best-effort */ }
-    }
-
     if (!isAutoActive() && !isAutoPaused()) return;
 
     // Save the current session — the lock file stays on disk
@@ -1084,11 +1019,7 @@ export default function (pi: ExtensionAPI) {
     }
   });
 
-  // ── tool_call: block CONTEXT.md writes without depth verification ──
-  // Active during both discussion flows (pendingAutoStart set) and
-  // queue flows (activeQueuePhase set). For multi-milestone queue flows,
-  // each milestone must pass its own depth verification before its
-  // CONTEXT.md can be written.
+  // ── tool_call: block CONTEXT.md writes during discussion without depth verification ──
   pi.on("tool_call", async (event) => {
     if (!isToolCallEventType("write", event)) return;
     const result = shouldBlockContextWrite(
@@ -1102,42 +1033,24 @@ export default function (pi: ExtensionAPI) {
   });
 
   // ── tool_result: persist discussion exchanges & detect depth gate ──────
-  // Handles both discussion flows and queue flows. For queue flows,
-  // depth verification question IDs may include milestone IDs
-  // (e.g., "depth_verification_M001") for per-milestone gating.
   pi.on("tool_result", async (event) => {
     if (event.toolName !== "ask_user_questions") return;
 
     const milestoneId = getDiscussionMilestoneId();
-    // Queue flows don't set pendingAutoStart, so milestoneId may be null.
-    // Depth gate detection still applies — it sets per-milestone flags.
-    const inQueue = activeQueuePhase;
+    if (!milestoneId) return;
 
     const details = event.details as any;
     if (details?.cancelled || !details?.response) return;
 
     // ── Depth gate detection ──────────────────────────────────────────
-    // Supports two patterns:
-    //   1. "depth_verification" — wildcard, marks all milestones verified
-    //   2. "depth_verification_M001" — per-milestone verification
     const questions: any[] = (event.input as any)?.questions ?? [];
     for (const q of questions) {
       if (typeof q.id === "string" && q.id.includes("depth_verification")) {
-        // Extract milestone ID from question ID if present
-        const midMatch = q.id.match(/depth_verification[_-](M\d+(?:-[a-z0-9]{6})?)/i);
-        if (midMatch) {
-          depthVerifiedMilestones.add(midMatch[1]);
-        } else {
-          // Wildcard — all milestones verified (backward compat for single-milestone)
-          depthVerifiedMilestones.add("*");
-        }
+        depthVerificationDone = true;
         break;
       }
     }
 
-    // Discussion persistence only applies when in a discussion flow with a known milestone
-    if (!milestoneId) return;
-
     // ── Persist exchange to DISCUSSION.md ──────────────────────────────
     const basePath = process.cwd();
     const milestoneDir = resolveMilestonePath(basePath, milestoneId);

package/src/resources/extensions/gsd/post-unit-hooks.ts

@@ -14,8 +14,6 @@ import type {
 import { resolvePostUnitHooks, resolvePreDispatchHooks } from "./preferences.js";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { gsdRoot } from "./paths.js";
-import { parseUnitId } from "./unit-id.js";
 
 // ─── Hook Queue State ──────────────────────────────────────────────────────
 
@@ -150,7 +148,7 @@ function dequeueNextHook(basePath: string): HookDispatchResult | null {
     };
 
     // Build the prompt with variable substitution
-    const { milestone: mid, slice: sid, task: tid } = parseUnitId(triggerUnitId);
+    const [mid, sid, tid] = triggerUnitId.split("/");
     const prompt = config.prompt
       .replace(/\{milestoneId\}/g, mid ?? "")
       .replace(/\{sliceId\}/g, sid ?? "")
@@ -209,14 +207,16 @@ function handleHookCompletion(basePath: string): HookDispatchResult | null {
  *   - Milestone-level (M001):    .gsd/M001/{artifact}
  */
 export function resolveHookArtifactPath(basePath: string, unitId: string, artifactName: string): string {
-  const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
-  if (mid && sid && tid) {
-    return join(gsdRoot(basePath), mid, "slices", sid, "tasks", `${tid}-${artifactName}`);
+  const parts = unitId.split("/");
+  if (parts.length === 3) {
+    const [mid, sid, tid] = parts;
+    return join(basePath, ".gsd", mid, "slices", sid, "tasks", `${tid}-${artifactName}`);
   }
-  if (mid && sid) {
-    return join(gsdRoot(basePath), mid, "slices", sid, artifactName);
+  if (parts.length === 2) {
+    const [mid, sid] = parts;
+    return join(basePath, ".gsd", mid, "slices", sid, artifactName);
   }
-  return join(gsdRoot(basePath), mid, artifactName);
+  return join(basePath, ".gsd", parts[0], artifactName);
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -252,7 +252,7 @@ export function runPreDispatchHooks(
     return { action: "proceed", prompt, firedHooks: [] };
   }
 
-  const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+  const [mid, sid, tid] = unitId.split("/");
   const substitute = (text: string): string =>
     text
       .replace(/\{milestoneId\}/g, mid ?? "")
@@ -310,7 +310,7 @@ export function runPreDispatchHooks(
 const HOOK_STATE_FILE = "hook-state.json";
 
 function hookStatePath(basePath: string): string {
-  return join(gsdRoot(basePath), HOOK_STATE_FILE);
+  return join(basePath, ".gsd", HOOK_STATE_FILE);
 }
 
 /**
@@ -323,7 +323,7 @@ export function persistHookState(basePath: string): void {
     savedAt: new Date().toISOString(),
   };
   try {
-    const dir = gsdRoot(basePath);
+    const dir = join(basePath, ".gsd");
     if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
     writeFileSync(hookStatePath(basePath), JSON.stringify(state, null, 2), "utf-8");
   } catch {
@@ -465,7 +465,7 @@ export function triggerHookManually(
   activeHook.cycle = currentCycle;
 
   // Build the prompt with variable substitution
-  const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+  const [mid, sid, tid] = unitId.split("/");
   const prompt = hook.prompt
     .replace(/\{milestoneId\}/g, mid ?? "")
     .replace(/\{sliceId\}/g, sid ?? "")