gsd-pi 2.78.1-dev.e9d88a536 → 2.78.1-dev.eccf86e27

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

@@ -11,7 +11,8 @@
  */
 import { deriveState } from "./state.js";
 import { parseUnitId } from "./unit-id.js";
-import { assessInterruptedSession, readPausedSessionMetadata, } from "./interrupted-session.js";
+import { assessInterruptedSession, readPausedSessionMetadata, PAUSED_SESSION_KV_KEY, } from "./interrupted-session.js";
+import { setRuntimeKv, deleteRuntimeKv, } from "./db/runtime-kv.js";
 import { getManifestStatus } from "./files.js";
 export { inlinePriorMilestoneSummary } from "./files.js";
 import { collectSecretsFromManifest } from "../get-secrets-from-user.js";
@@ -40,7 +41,7 @@ import { setLogBasePath, logWarning } from "./workflow-logger.js";
 import { preflightCleanRoot, postflightPopStash } from "./clean-root-preflight.js";
 import { isAbsolute, join } from "node:path";
 import { pathToFileURL } from "node:url";
-import { readFileSync, existsSync, mkdirSync, unlinkSync } from "node:fs";
+import { readFileSync, existsSync, mkdirSync } from "node:fs";
 import { atomicWriteSync } from "./atomic-write.js";
 import { autoCommitCurrentBranch, captureIntegrationBranch, detectWorktreeName, getCurrentBranch, getMainBranch, setActiveMilestoneId, } from "./worktree.js";
 import { GitServiceImpl } from "./git-service.js";
@@ -86,6 +87,10 @@ import { reorderForCaching } from "./prompt-ordering.js";
 export { STUB_RECOVERY_THRESHOLD, NEW_SESSION_TIMEOUT_MS, } from "./auto/session.js";
 import { autoSession as s } from "./auto-runtime-state.js";
 import { gsdHome } from "./gsd-home.js";
+import { createWorkspace, scopeMilestone } from "./workspace.js";
+import { registerAutoWorker, markWorkerStopping } from "./db/auto-workers.js";
+import { releaseMilestoneLease } from "./db/milestone-leases.js";
+import { normalizeRealPath } from "./paths.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.
@@ -100,6 +105,27 @@ import { gsdHome } from "./gsd-home.js";
 // ─────────────────────────────────────────────────────────────────────────────
 /** Throttle STATE.md rebuilds — at most once per 30 seconds */
 const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
+/**
+ * Phase B — register this auto-mode process in the workers table so other
+ * workers and janitors can detect liveness via heartbeat. Best-effort: if
+ * the DB is unavailable (e.g. fresh project before init) we skip registration
+ * silently rather than blocking session start.
+ */
+function registerAutoWorkerForSession(session) {
+    if (session.workerId)
+        return; // already registered (e.g. resume re-runs)
+    try {
+        const projectRootRealpath = normalizeRealPath(session.scope?.workspace.projectRoot
+            ?? (session.originalBasePath || session.basePath));
+        session.workerId = registerAutoWorker({ projectRootRealpath });
+    }
+    catch (err) {
+        debugLog("autoLoop", {
+            phase: "register-worker-failed",
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+}
 function captureProjectRootEnv(projectRoot) {
     if (!s.projectRootEnvCaptured) {
         s.hadProjectRootEnv = Object.prototype.hasOwnProperty.call(process.env, "GSD_PROJECT_ROOT");
@@ -147,6 +173,32 @@ function restoreMilestoneLockEnv() {
     s.hadMilestoneLockEnv = false;
     s.milestoneLockEnvCaptured = false;
 }
+/**
+ * Rebuild s.scope from the current s.basePath / s.originalBasePath / s.currentMilestoneId.
+ *
+ * Pass the worktree path as rawPath when entering a worktree so createWorkspace
+ * can detect the worktree layout and set mode="worktree". When no worktree is
+ * active, rawPath should equal the project root.
+ *
+ * Clears s.scope when milestoneId is absent — scope is only meaningful when a
+ * milestone is active.
+ *
+ * TODO(C8): remove basePath/originalBasePath once all readers use s.scope.
+ */
+function rebuildScope(rawPath, milestoneId) {
+    if (!milestoneId) {
+        s.scope = null;
+        return;
+    }
+    try {
+        const workspace = createWorkspace(rawPath);
+        s.scope = scopeMilestone(workspace, milestoneId);
+    }
+    catch {
+        // Non-fatal — scope is additive. Existing readers still use basePath.
+        s.scope = null;
+    }
+}
 function normalizeSessionFilePath(raw) {
     if (typeof raw !== "string")
         return null;
@@ -284,6 +336,18 @@ export function isAutoActive() {
 export function _setAutoActiveForTest(active) {
     s.active = active;
 }
+/**
+ * Test-only seam: emit the missing-worktree warning exactly as the resume path
+ * does.  Allows unit tests to verify the warning is produced without
+ * bootstrapping the full auto-mode entry point.  Do not use in production code.
+ */
+export function _warnIfWorktreeMissingForTest(worktreePath, milestoneId) {
+    if (worktreePath && !existsSync(worktreePath)) {
+        logWarning("session", `Worktree was expected at ${worktreePath} but is missing. Continuing in project-root mode. To restart with a fresh worktree, run /gsd-debug or recreate the milestone.`, { file: "auto.ts", milestoneId });
+        return true;
+    }
+    return false;
+}
 export function isAutoPaused() {
     return s.paused;
 }
@@ -582,6 +646,21 @@ export async function stopAuto(ctx, pi, reason) {
         catch (e) {
             debugLog("stop-cleanup-locks", { error: e instanceof Error ? e.message : String(e) });
         }
+        // ── Step 1b: Coordination cleanup (Phase B) ──
+        // Release any active milestone lease so other workers don't have to
+        // wait for TTL expiry, then mark this worker as stopping. Best-effort:
+        // DB unavailability or stale state must not block shutdown.
+        try {
+            if (s.workerId && s.currentMilestoneId && s.milestoneLeaseToken) {
+                releaseMilestoneLease(s.workerId, s.currentMilestoneId, s.milestoneLeaseToken);
+            }
+            if (s.workerId) {
+                markWorkerStopping(s.workerId);
+            }
+        }
+        catch (e) {
+            debugLog("stop-cleanup-coordination", { error: e instanceof Error ? e.message : String(e) });
+        }
         // ── Step 1b: Flush queued follow-up messages (#3512) ──
         // Late async notifications (async_job_result, gsd-auto-wrapup) can trigger
         // extra LLM turns after stop. Flush them the same way run-unit.ts does.
@@ -760,13 +839,12 @@ export async function stopAuto(ctx, pi, reason) {
             debugLog("stop-cleanup-metrics", { error: e instanceof Error ? e.message : String(e) });
         }
         // ── Step 12: Remove paused-session metadata (#1383) ──
+        // Phase C pt 2: deleteRuntimeKv replaces unlinkSync(paused-session.json).
         try {
-            const pausedPath = join(gsdRoot(s.originalBasePath || s.basePath), "runtime", "paused-session.json");
-            if (existsSync(pausedPath))
-                unlinkSync(pausedPath);
+            deleteRuntimeKv("global", "", PAUSED_SESSION_KV_KEY);
         }
         catch (err) { /* non-fatal */
-            logWarning("engine", `file unlink failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
+            logWarning("engine", `paused-session DB delete failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
         }
         // ── Step 13: Restore original model + thinking (before reset clears IDs) ──
         try {
@@ -858,10 +936,12 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
     resolveAgentEndCancelled(_errorContext);
     s.pausedSessionFile = normalizeSessionFilePath(ctx?.sessionManager?.getSessionFile() ?? null);
     // Persist paused-session metadata so resume survives /exit (#1383).
-    // The fresh-start bootstrap checks for this file and restores worktree context.
+    // Phase C pt 2: persisted to runtime_kv (global scope, key
+    // PAUSED_SESSION_KV_KEY) instead of runtime/paused-session.json. The
+    // fresh-start bootstrap below reads from the same key.
     try {
         const pausedMeta = {
-            milestoneId: s.currentMilestoneId,
+            milestoneId: s.currentMilestoneId ?? undefined,
             worktreePath: isInAutoWorktree(s.basePath) ? s.basePath : null,
             originalBasePath: s.originalBasePath,
             stepMode: s.stepMode,
@@ -869,17 +949,16 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
             sessionFile: s.pausedSessionFile,
             unitType: s.currentUnit?.type ?? undefined,
             unitId: s.currentUnit?.id ?? undefined,
-            activeEngineId: s.activeEngineId,
+            activeEngineId: s.activeEngineId ?? undefined,
             activeRunDir: s.activeRunDir,
             autoStartTime: s.autoStartTime,
             milestoneLock: s.sessionMilestoneLock ?? undefined,
         };
-        const runtimeDir = join(gsdRoot(s.originalBasePath || s.basePath), "runtime");
-        atomicWriteSync(join(runtimeDir, "paused-session.json"), JSON.stringify(pausedMeta, null, 2), "utf-8");
+        setRuntimeKv("global", "", PAUSED_SESSION_KV_KEY, pausedMeta);
     }
     catch (err) {
         // Non-fatal — resume will still work via full bootstrap, just without worktree context
-        logWarning("engine", `paused-session file write failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
+        logWarning("engine", `paused-session DB write failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
     }
     // Close out the current unit so its runtime record doesn't stay at "dispatched"
     if (s.currentUnit && ctx) {
@@ -1115,8 +1194,10 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     if (recoverFailedMigration(base)) {
         ctx.ui.notify("Recovered unfinished migration (.gsd.migrating → .gsd).", "info");
     }
-    const freshStartAssessment = interruptedAssessment
-        ?? await assessInterruptedSession(base);
+    const freshStartAssessment = await (interruptedAssessment
+        ?? (() => {
+            return ensureDbOpen(base).then(() => assessInterruptedSession(base));
+        })());
     if (freshStartAssessment.classification === "running") {
         const pid = freshStartAssessment.lock?.pid;
         ctx.ui.notify(pid
@@ -1126,10 +1207,20 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     }
     // If resuming from paused state, just re-activate and dispatch next unit.
     // Check persisted paused-session first (#1383) — survives /exit.
+    // Phase C pt 2: persisted in runtime_kv (global scope) instead of
+    // runtime/paused-session.json. The `clearPausedSession` helper
+    // replaces every prior unlinkSync(pausedPath) call.
+    const clearPausedSession = (logTag) => {
+        try {
+            deleteRuntimeKv("global", "", PAUSED_SESSION_KV_KEY);
+        }
+        catch (err) {
+            logWarning("session", `${logTag}: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
+        }
+    };
     if (!s.paused) {
         try {
             const meta = freshStartAssessment.pausedSession ?? readPausedSessionMetadata(base);
-            const pausedPath = join(gsdRoot(base), "runtime", "paused-session.json");
             if (meta?.activeEngineId && meta.activeEngineId !== "dev") {
                 // Custom workflow resume — restore engine state
                 s.activeEngineId = meta.activeEngineId;
@@ -1139,14 +1230,6 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                 s.autoStartTime = meta.autoStartTime || Date.now();
                 s.sessionMilestoneLock = meta.milestoneLock ?? null;
                 s.paused = true;
-                try {
-                    unlinkSync(pausedPath);
-                }
-                catch (e) {
-                    if (e.code !== "ENOENT") {
-                        logWarning("session", `pause file cleanup failed: ${e instanceof Error ? e.message : String(e)}`, { file: "auto.ts" });
-                    }
-                }
                 ctx.ui.notify(`Resuming paused custom workflow${meta.activeRunDir ? ` (${meta.activeRunDir})` : ""}.`, "info");
             }
             else if (meta?.milestoneId) {
@@ -1184,14 +1267,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                         }
                     }
                     if (!mDir || summaryIsTerminal) {
-                        try {
-                            unlinkSync(pausedPath);
-                        }
-                        catch (err) {
-                            if (err.code !== "ENOENT") {
-                                logWarning("session", `pause file cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
-                            }
-                        }
+                        clearPausedSession("paused-session DB cleanup failed (milestone gone/complete)");
                         ctx.ui.notify(`Paused milestone ${meta.milestoneId} is ${!mDir ? "missing" : "already complete"}. Starting fresh.`, "info");
                     }
                     else {
@@ -1204,26 +1280,25 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                         s.autoStartTime = meta.autoStartTime || Date.now();
                         s.sessionMilestoneLock = meta.milestoneLock ?? null;
                         s.paused = true;
-                        try {
-                            unlinkSync(pausedPath);
-                        }
-                        catch (e) {
-                            if (e.code !== "ENOENT") {
-                                logWarning("session", `pause file cleanup failed: ${e instanceof Error ? e.message : String(e)}`, { file: "auto.ts" });
+                        // Build scope from persisted state. Use worktreePath when present and
+                        // still on disk so mode is detected correctly; fall back to project root.
+                        {
+                            const persistedWorktreePath = meta.worktreePath ?? null;
+                            if (persistedWorktreePath && !existsSync(persistedWorktreePath)) {
+                                logWarning("session", `Worktree was expected at ${persistedWorktreePath} but is missing. Continuing in project-root mode. To restart with a fresh worktree, run /gsd-debug or recreate the milestone.`, { file: "auto.ts", milestoneId: meta.milestoneId ?? "" });
                             }
+                            const rawForScope = (persistedWorktreePath && existsSync(persistedWorktreePath))
+                                ? persistedWorktreePath
+                                : (s.originalBasePath || base);
+                            rebuildScope(rawForScope, s.currentMilestoneId);
                         }
                         ctx.ui.notify(`Resuming paused session for ${meta.milestoneId}${meta.worktreePath && existsSync(meta.worktreePath) ? ` (worktree)` : ""}.`, "info");
                     }
                 }
-                else if (existsSync(pausedPath)) {
-                    try {
-                        unlinkSync(pausedPath);
-                    }
-                    catch (e) {
-                        if (e.code !== "ENOENT") {
-                            logWarning("session", `stale pause file cleanup failed: ${e instanceof Error ? e.message : String(e)}`, { file: "auto.ts" });
-                        }
-                    }
+                else if (meta) {
+                    // Stale paused-session metadata that the assessment chose not to
+                    // resume — clean it up so the next bootstrap starts fresh.
+                    clearPausedSession("stale paused-session DB cleanup failed");
                 }
             }
         }
@@ -1285,10 +1360,15 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         // session (e.g. isolation mode changed, detectWorktreeName differs across
         // process restarts).  We guard with existsSync so a stale or deleted
         // worktree directory safely falls back to the project root.
-        const resumeWorktreePath = freshStartAssessment.pausedSession?.worktreePath;
+        const resumeWorktreePath = freshStartAssessment.pausedSession?.worktreePath ?? null;
+        if (resumeWorktreePath && !existsSync(resumeWorktreePath)) {
+            logWarning("session", `Worktree was expected at ${resumeWorktreePath} but is missing. Continuing in project-root mode. To restart with a fresh worktree, run /gsd-debug or recreate the milestone.`, { file: "auto.ts", milestoneId: s.currentMilestoneId ?? "" });
+        }
         if (resumeWorktreePath && existsSync(resumeWorktreePath)) {
             s.basePath = resumeWorktreePath;
         }
+        // Rebuild scope now that s.basePath reflects the actual worktree (or project root).
+        rebuildScope(s.basePath, s.currentMilestoneId);
         // Ensure the workflow-logger audit log is pinned to the project root
         // even when auto-mode is entered via a path that bypasses the
         // bootstrap/dynamic-tools ensureDbOpen() → setLogBasePath() chain
@@ -1315,6 +1395,8 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             buildResolver().enterMilestone(s.currentMilestoneId, {
                 notify: ctx.ui.notify.bind(ctx.ui),
             });
+            // s.basePath may have been updated to a worktree path by enterMilestone.
+            rebuildScope(s.basePath, s.currentMilestoneId);
         }
         registerSigtermHandler(lockBase());
         ctx.ui.setStatus("gsd-auto", s.stepMode ? "next" : "auto");
@@ -1367,10 +1449,14 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             }
             s.pausedSessionFile = null;
         }
+        captureProjectRootEnv(s.originalBasePath || s.basePath);
+        registerAutoWorkerForSession(s);
         updateSessionLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown");
-        writeLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown");
+        if (s.workerId) {
+            writeLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown");
+            clearPausedSession("paused-session DB cleanup failed (resume activation)");
+        }
         pi.events.emit(CMUX_CHANNELS.LOG, { preferences: loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, message: s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", level: "progress" });
-        captureProjectRootEnv(s.originalBasePath || s.basePath);
         startAutoCommandPolling(s.basePath);
         await runAutoLoopWithUok({
             ctx,
@@ -1393,7 +1479,11 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     const ready = await bootstrapAutoSession(s, ctx, pi, base, verboseMode, requestedStepMode, bootstrapDeps, freshStartAssessment);
     if (!ready)
         return;
+    // Build scope after bootstrap has populated s.basePath / s.originalBasePath /
+    // s.currentMilestoneId (including worktree setup inside bootstrapAutoSession).
+    rebuildScope(s.basePath, s.currentMilestoneId);
     captureProjectRootEnv(s.originalBasePath || s.basePath);
+    registerAutoWorkerForSession(s);
     try {
         pi.events.emit(CMUX_CHANNELS.SIDEBAR, { action: "sync", preferences: loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, state: await deriveState(s.basePath) });
     }

package/dist/resources/extensions/gsd/bootstrap/agent-end-recovery.js

@@ -86,7 +86,7 @@ export async function handleAgentEnd(pi, event, ctx) {
         logWarning("bootstrap", `checkDeepProjectSetupAfterTurn failed: ${message}`);
     }
     if (checkAutoStartAfterDiscuss()) {
-        clearDiscussionFlowState();
+        clearDiscussionFlowState(resolveAgentEndBasePath() ?? process.cwd());
         return;
     }
     // #4573 — When the LLM emits "Milestone X ready." but the required files

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

@@ -60,7 +60,7 @@ export function registerHooks(pi, ecosystemHandlers) {
             const { initHealthWidget } = await import("../health-widget.js");
             initHealthWidget(ctx);
         }
-        resetWriteGateState();
+        resetWriteGateState(process.cwd());
         resetToolCallLoopGuard();
         approvalQuestionAbortInFlight = false;
         await resetAskUserQuestionsTurnCache();
@@ -109,10 +109,10 @@ export function registerHooks(pi, ecosystemHandlers) {
     pi.on("session_switch", async (_event, ctx) => {
         initNotificationStore(process.cwd());
         installNotifyInterceptor(ctx);
-        resetWriteGateState();
+        resetWriteGateState(process.cwd());
         resetToolCallLoopGuard();
         await resetAskUserQuestionsTurnCache();
-        clearDiscussionFlowState();
+        clearDiscussionFlowState(process.cwd());
         await syncServiceTierStatus(ctx);
         await applyDisabledModelProviderPolicy(ctx);
         // Skip MCP auto-prep when running inside an auto-worktree. The worktree
@@ -137,13 +137,14 @@ export function registerHooks(pi, ecosystemHandlers) {
         // Wait for ecosystem loader to finish (no-op after first turn).
         const { getEcosystemReadyPromise } = await import("../ecosystem/loader.js");
         await getEcosystemReadyPromise();
+        const beforeAgentBasePath = process.cwd();
         const pendingApprovalGate = getPendingGate();
         if (pendingApprovalGate && isExplicitApprovalResponse(event.prompt, pendingApprovalGate)) {
-            markApprovalGateVerified(pendingApprovalGate);
+            markApprovalGateVerified(pendingApprovalGate, beforeAgentBasePath);
             const milestoneId = extractDepthVerificationMilestoneId(pendingApprovalGate);
             if (milestoneId)
-                markDepthVerified(milestoneId);
-            clearPendingGate();
+                markDepthVerified(milestoneId, beforeAgentBasePath);
+            clearPendingGate(beforeAgentBasePath);
         }
         // GSD's own context injection (existing behavior — unchanged).
         const { buildBeforeAgentStartResult } = await import("./system-context.js");
@@ -318,7 +319,7 @@ export function registerHooks(pi, ecosystemHandlers) {
             return;
         const gateId = approvalGateIdForUnit(unitType, unitId);
         if (gateId)
-            setPendingGate(gateId);
+            setPendingGate(gateId, process.cwd());
         approvalQuestionAbortInFlight = true;
         ctx.ui.notify(`${unitType}${unitId ? ` ${unitId}` : ""} is waiting for your approval - pausing before more tool calls run.`, "info");
         // The pending gate set above blocks subsequent non-read-only tool calls
@@ -360,7 +361,7 @@ export function registerHooks(pi, ecosystemHandlers) {
             const questions = event.input?.questions ?? [];
             const questionId = questions.find((question) => typeof question?.id === "string" && isGateQuestionId(question.id))?.id;
             if (typeof questionId === "string") {
-                setPendingGate(questionId);
+                setPendingGate(questionId, discussionBasePath);
             }
         }
         // ── Discussion gate enforcement: block tool calls while gate is pending ──
@@ -501,7 +502,8 @@ export function registerHooks(pi, ecosystemHandlers) {
         const toolName = canonicalToolName(event.toolName);
         if (toolName !== "ask_user_questions")
             return;
-        const milestoneId = await getDiscussionMilestoneIdFor(process.cwd());
+        const basePath = process.cwd();
+        const milestoneId = await getDiscussionMilestoneIdFor(basePath);
         const queueActive = isQueuePhaseActive();
         const details = event.details;
         // ── Discussion gate enforcement: handle gate question responses ──
@@ -513,8 +515,13 @@ export function registerHooks(pi, ecosystemHandlers) {
         const currentPendingGate = getPendingGate();
         if (currentPendingGate) {
             if (details?.cancelled || !details?.response) {
-                // Gate stays pending. Return a hard instruction as the tool result so
-                // the model cannot reinterpret a cancelled prompt as prior approval.
+                // Gate stays pending. Direct the agent to the most reliable recovery
+                // path — re-calling ask_user_questions with the same gate id — without
+                // misrepresenting the plain-text path. The plain-text path also works
+                // (isExplicitApprovalResponse on the next before_agent_start clears
+                // the gate when the user replies with an approval keyword), but the
+                // structured re-ask is more deterministic and gives the user a clear UI.
+                resetToolCallLoopGuard();
                 return {
                     content: [{
                             type: "text",
@@ -522,8 +529,8 @@ export function registerHooks(pi, ecosystemHandlers) {
                                 `HARD BLOCK: approval gate "${currentPendingGate}" is still pending.`,
                                 "No user response was received for the confirmation question.",
                                 "Do not infer approval from earlier or prior messages.",
-                                "Do not proceed, write files, save artifacts, or call more tools.",
-                                "Ask the user to confirm in plain chat, then stop and wait for their next message.",
+                                "Do not proceed, write files, save artifacts, or call other tools.",
+                                `Re-call ask_user_questions with the same gate question id ("${currentPendingGate}") and wait for the user's response.`,
                             ].join(" "),
                         }],
                 };
@@ -533,11 +540,11 @@ export function registerHooks(pi, ecosystemHandlers) {
                 if (pendingQuestion) {
                     const answer = details.response?.answers?.[currentPendingGate];
                     if (isDepthConfirmationAnswer(answer?.selected, pendingQuestion.options)) {
-                        markApprovalGateVerified(currentPendingGate);
+                        markApprovalGateVerified(currentPendingGate, basePath);
                         const milestoneIdFromGate = extractDepthVerificationMilestoneId(currentPendingGate);
                         if (milestoneIdFromGate)
-                            markDepthVerified(milestoneIdFromGate);
-                        clearPendingGate();
+                            markDepthVerified(milestoneIdFromGate, basePath);
+                        clearPendingGate(basePath);
                     }
                 }
             }
@@ -553,9 +560,9 @@ export function registerHooks(pi, ecosystemHandlers) {
                 if (isDepthConfirmationAnswer(answer?.selected, question.options)) {
                     if (currentPendingGate && question.id !== currentPendingGate)
                         break;
-                    markApprovalGateVerified(question.id);
-                    markDepthVerified(inferredMilestoneId);
-                    clearPendingGate();
+                    markApprovalGateVerified(question.id, basePath);
+                    markDepthVerified(inferredMilestoneId, basePath);
+                    clearPendingGate(basePath);
                 }
                 break;
             }
@@ -564,7 +571,6 @@ export function registerHooks(pi, ecosystemHandlers) {
             return;
         if (!milestoneId)
             return;
-        const basePath = process.cwd();
         const milestoneDir = resolveMilestonePath(basePath, milestoneId);
         if (!milestoneDir)
             return;