gsd-pi 2.38.0-dev.eeb3520 → 2.39.0-dev.20aba06

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

@@ -31,7 +31,7 @@ import { syncProjectRootToWorktree, checkResourcesStale, escapeStaleWorktree, }
 import { resetRoutingHistory, recordOutcome } from "./routing-history.js";
 import { resetHookState, runPreDispatchHooks, restoreHookState, clearPersistedHookState, } from "./post-unit-hooks.js";
 import { runGSDDoctor, rebuildState } from "./doctor.js";
-import { preDispatchHealthGate, resetProactiveHealing, } from "./doctor-proactive.js";
+import { preDispatchHealthGate, resetProactiveHealing, setLevelChangeCallback, } from "./doctor-proactive.js";
 import { clearSkillSnapshot } from "./skill-discovery.js";
 import { captureAvailableSkills, resetSkillTelemetry, } from "./skill-telemetry.js";
 import { initMetrics, resetMetrics, getLedger, getProjectTotals, formatCost, formatTokenCount, } from "./metrics.js";
@@ -56,7 +56,7 @@ import { startUnitSupervision } from "./auto-timers.js";
 import { runPostUnitVerification } from "./auto-verification.js";
 import { postUnitPreVerification, postUnitPostVerification, } from "./auto-post-unit.js";
 import { bootstrapAutoSession } from "./auto-start.js";
-import { autoLoop, resolveAgentEnd } from "./auto-loop.js";
+import { autoLoop, resolveAgentEnd, isSessionSwitchInFlight } from "./auto-loop.js";
 import { WorktreeResolver, } from "./worktree-resolver.js";
 import { reorderForCaching } from "./prompt-ordering.js";
 // Worktree sync, resource staleness, stale worktree escape → auto-worktree-sync.ts
@@ -297,116 +297,164 @@ export async function stopAuto(ctx, pi, reason) {
         return;
     const loadedPreferences = loadEffectiveGSDPreferences()?.preferences;
     const reasonSuffix = reason ? ` — ${reason}` : "";
-    clearUnitTimeout();
-    if (lockBase())
-        clearLock(lockBase());
-    if (lockBase())
-        releaseSessionLock(lockBase());
-    clearSkillSnapshot();
-    resetSkillTelemetry();
-    // Remove SIGTERM handler registered at auto-mode start
-    deregisterSigtermHandler();
-    // ── Auto-worktree: exit worktree and reset s.basePath on stop ──
-    if (s.currentMilestoneId) {
-        const notifyCtx = ctx
-            ? { notify: ctx.ui.notify.bind(ctx.ui) }
-            : { notify: () => { } };
-        buildResolver().exitMilestone(s.currentMilestoneId, notifyCtx, {
-            preserveBranch: true,
-        });
-    }
-    // ── DB cleanup: close the SQLite connection ──
-    if (isDbAvailable()) {
+    try {
+        // ── Step 1: Timers and locks ──
         try {
-            const { closeDatabase } = await import("./gsd-db.js");
-            closeDatabase();
+            clearUnitTimeout();
+            if (lockBase())
+                clearLock(lockBase());
+            if (lockBase())
+                releaseSessionLock(lockBase());
         }
         catch (e) {
-            debugLog("db-close-failed", {
-                error: e instanceof Error ? e.message : String(e),
-            });
+            debugLog("stop-cleanup-locks", { error: e instanceof Error ? e.message : String(e) });
         }
-    }
-    if (s.originalBasePath) {
-        s.basePath = s.originalBasePath;
+        // ── Step 2: Skill state ──
         try {
-            process.chdir(s.basePath);
+            clearSkillSnapshot();
+            resetSkillTelemetry();
         }
-        catch {
-            /* best-effort */
+        catch (e) {
+            debugLog("stop-cleanup-skills", { error: e instanceof Error ? e.message : String(e) });
         }
-    }
-    const ledger = getLedger();
-    if (ledger && ledger.units.length > 0) {
-        const totals = getProjectTotals(ledger.units);
-        ctx?.ui.notify(`Auto-mode stopped${reasonSuffix}. Session: ${formatCost(totals.cost)} · ${formatTokenCount(totals.tokens.total)} tokens · ${ledger.units.length} units`, "info");
-    }
-    else {
-        ctx?.ui.notify(`Auto-mode stopped${reasonSuffix}.`, "info");
-    }
-    if (s.basePath) {
+        // ── Step 3: SIGTERM handler ──
         try {
-            await rebuildState(s.basePath);
+            deregisterSigtermHandler();
         }
         catch (e) {
-            debugLog("stop-rebuild-state-failed", {
-                error: e instanceof Error ? e.message : String(e),
-            });
+            debugLog("stop-cleanup-sigterm", { error: e instanceof Error ? e.message : String(e) });
         }
-    }
-    clearCmuxSidebar(loadedPreferences);
-    logCmuxEvent(loadedPreferences, `Auto-mode stopped${reasonSuffix || ""}.`, reason?.startsWith("Blocked:") ? "warning" : "info");
-    if (isDebugEnabled()) {
-        const logPath = writeDebugSummary();
-        if (logPath) {
-            ctx?.ui.notify(`Debug log written → ${logPath}`, "info");
+        // ── Step 4: Auto-worktree exit ──
+        try {
+            if (s.currentMilestoneId) {
+                const notifyCtx = ctx
+                    ? { notify: ctx.ui.notify.bind(ctx.ui) }
+                    : { notify: () => { } };
+                buildResolver().exitMilestone(s.currentMilestoneId, notifyCtx, {
+                    preserveBranch: true,
+                });
+            }
+        }
+        catch (e) {
+            debugLog("stop-cleanup-worktree", { error: e instanceof Error ? e.message : String(e) });
+        }
+        // ── Step 5: DB cleanup ──
+        if (isDbAvailable()) {
+            try {
+                const { closeDatabase } = await import("./gsd-db.js");
+                closeDatabase();
+            }
+            catch (e) {
+                debugLog("db-close-failed", {
+                    error: e instanceof Error ? e.message : String(e),
+                });
+            }
+        }
+        // ── Step 6: Restore basePath and chdir ──
+        try {
+            if (s.originalBasePath) {
+                s.basePath = s.originalBasePath;
+                try {
+                    process.chdir(s.basePath);
+                }
+                catch {
+                    /* best-effort */
+                }
+            }
+        }
+        catch (e) {
+            debugLog("stop-cleanup-basepath", { error: e instanceof Error ? e.message : String(e) });
+        }
+        // ── Step 7: Ledger notification ──
+        try {
+            const ledger = getLedger();
+            if (ledger && ledger.units.length > 0) {
+                const totals = getProjectTotals(ledger.units);
+                ctx?.ui.notify(`Auto-mode stopped${reasonSuffix}. Session: ${formatCost(totals.cost)} · ${formatTokenCount(totals.tokens.total)} tokens · ${ledger.units.length} units`, "info");
+            }
+            else {
+                ctx?.ui.notify(`Auto-mode stopped${reasonSuffix}.`, "info");
+            }
+        }
+        catch (e) {
+            debugLog("stop-cleanup-ledger", { error: e instanceof Error ? e.message : String(e) });
+        }
+        // ── Step 8: Rebuild state ──
+        if (s.basePath) {
+            try {
+                await rebuildState(s.basePath);
+            }
+            catch (e) {
+                debugLog("stop-rebuild-state-failed", {
+                    error: e instanceof Error ? e.message : String(e),
+                });
+            }
+        }
+        // ── Step 9: Cmux sidebar / event log ──
+        try {
+            clearCmuxSidebar(loadedPreferences);
+            logCmuxEvent(loadedPreferences, `Auto-mode stopped${reasonSuffix || ""}.`, reason?.startsWith("Blocked:") ? "warning" : "info");
+        }
+        catch (e) {
+            debugLog("stop-cleanup-cmux", { error: e instanceof Error ? e.message : String(e) });
+        }
+        // ── Step 10: Debug summary ──
+        try {
+            if (isDebugEnabled()) {
+                const logPath = writeDebugSummary();
+                if (logPath) {
+                    ctx?.ui.notify(`Debug log written → ${logPath}`, "info");
+                }
+            }
+        }
+        catch (e) {
+            debugLog("stop-cleanup-debug", { error: e instanceof Error ? e.message : String(e) });
+        }
+        // ── Step 11: Reset metrics, routing, hooks ──
+        try {
+            resetMetrics();
+            resetRoutingHistory();
+            resetHookState();
+            if (s.basePath)
+                clearPersistedHookState(s.basePath);
+        }
+        catch (e) {
+            debugLog("stop-cleanup-metrics", { error: e instanceof Error ? e.message : String(e) });
+        }
+        // ── Step 12: Remove paused-session metadata (#1383) ──
+        try {
+            const pausedPath = join(gsdRoot(s.originalBasePath || s.basePath), "runtime", "paused-session.json");
+            if (existsSync(pausedPath))
+                unlinkSync(pausedPath);
+        }
+        catch { /* non-fatal */ }
+        // ── Step 13: Restore original model (before reset clears IDs) ──
+        try {
+            if (pi && ctx && s.originalModelId && s.originalModelProvider) {
+                const original = ctx.modelRegistry.find(s.originalModelProvider, s.originalModelId);
+                if (original)
+                    await pi.setModel(original);
+            }
+        }
+        catch (e) {
+            debugLog("stop-cleanup-model", { error: e instanceof Error ? e.message : String(e) });
         }
     }
-    resetMetrics();
-    resetRoutingHistory();
-    resetHookState();
-    if (s.basePath)
-        clearPersistedHookState(s.basePath);
-    // Remove paused-session metadata if present (#1383)
-    try {
-        const pausedPath = join(gsdRoot(s.originalBasePath || s.basePath), "runtime", "paused-session.json");
-        if (existsSync(pausedPath))
-            unlinkSync(pausedPath);
-    }
-    catch { /* non-fatal */ }
-    s.active = false;
-    s.paused = false;
-    s.stepMode = false;
-    s.unitDispatchCount.clear();
-    s.unitRecoveryCount.clear();
-    clearInFlightTools();
-    s.lastBudgetAlertLevel = 0;
-    s.lastStateRebuildAt = 0;
-    s.unitLifetimeDispatches.clear();
-    s.currentUnit = null;
-    s.autoModeStartModel = null;
-    s.currentMilestoneId = null;
-    s.originalBasePath = "";
-    s.completedUnits = [];
-    s.pendingQuickTasks = [];
-    clearSliceProgressCache();
-    clearActivityLogState();
-    resetProactiveHealing();
-    s.pendingCrashRecovery = null;
-    s.pendingVerificationRetry = null;
-    s.verificationRetryCount.clear();
-    s.pausedSessionFile = null;
-    ctx?.ui.setStatus("gsd-auto", undefined);
-    ctx?.ui.setWidget("gsd-progress", undefined);
-    ctx?.ui.setFooter(undefined);
-    if (pi && ctx && s.originalModelId && s.originalModelProvider) {
-        const original = ctx.modelRegistry.find(s.originalModelProvider, s.originalModelId);
-        if (original)
-            await pi.setModel(original);
-        s.originalModelId = null;
-        s.originalModelProvider = null;
+    finally {
+        // ── Critical invariants: these MUST execute regardless of errors ──
+        // External cleanup (not covered by session reset)
+        clearInFlightTools();
+        clearSliceProgressCache();
+        clearActivityLogState();
+        setLevelChangeCallback(null);
+        resetProactiveHealing();
+        // UI cleanup
+        ctx?.ui.setStatus("gsd-auto", undefined);
+        ctx?.ui.setWidget("gsd-progress", undefined);
+        ctx?.ui.setFooter(undefined);
+        // Reset all session state in one call
+        s.reset();
     }
-    s.cmdCtx = null;
 }
 /**
  * Pause auto-mode without destroying state. Context is preserved.
@@ -736,6 +784,7 @@ const widgetStateAccessors = {
     getCmdCtx: () => s.cmdCtx,
     getBasePath: () => s.basePath,
     isVerbose: () => s.verbose,
+    isSessionSwitching: isSessionSwitchInFlight,
 };
 // ─── Preconditions ────────────────────────────────────────────────────────────
 /**
@@ -777,8 +826,6 @@ function buildRecoveryContext() {
         unitRecoveryCount: s.unitRecoveryCount,
     };
 }
-// Re-export recovery functions for external consumers
-export { resolveExpectedArtifactPath, verifyExpectedArtifact, writeBlockerPlaceholder, skipExecuteTask, buildLoopRemediationSteps, } from "./auto-recovery.js";
 /**
  * Test-only: expose skip-loop state for unit tests.
  * Not part of the public API.
@@ -871,3 +918,5 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
 }
 // Direct phase dispatch → auto-direct-dispatch.ts
 export { dispatchDirectPhase } from "./auto-direct-dispatch.js";
+// Re-export recovery functions for external consumers
+export { resolveExpectedArtifactPath, verifyExpectedArtifact, writeBlockerPlaceholder, skipExecuteTask, buildLoopRemediationSteps, } from "./auto-recovery.js";

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

@@ -0,0 +1,126 @@
+import { checkAutoStartAfterDiscuss } from "../guided-flow.js";
+import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, pauseAuto } from "../auto.js";
+import { getNextFallbackModel, isTransientNetworkError, resolveModelWithFallbacksForUnit } from "../preferences.js";
+import { classifyProviderError, pauseAutoForProviderError } from "../provider-error-pause.js";
+import { isSessionSwitchInFlight, resolveAgentEnd } from "../auto-loop.js";
+import { clearDiscussionFlowState } from "./write-gate.js";
+const networkRetryCounters = new Map();
+const MAX_TRANSIENT_AUTO_RESUMES = 3;
+let consecutiveTransientErrors = 0;
+export async function handleAgentEnd(pi, event, ctx) {
+    if (checkAutoStartAfterDiscuss()) {
+        clearDiscussionFlowState();
+        return;
+    }
+    if (!isAutoActive())
+        return;
+    if (isSessionSwitchInFlight())
+        return;
+    const lastMsg = event.messages[event.messages.length - 1];
+    if (lastMsg && "stopReason" in lastMsg && lastMsg.stopReason === "aborted") {
+        await pauseAuto(ctx, pi);
+        return;
+    }
+    if (lastMsg && "stopReason" in lastMsg && lastMsg.stopReason === "error") {
+        const errorDetail = "errorMessage" in lastMsg && lastMsg.errorMessage ? `: ${lastMsg.errorMessage}` : "";
+        const errorMsg = ("errorMessage" in lastMsg && lastMsg.errorMessage) ? String(lastMsg.errorMessage) : "";
+        if (isTransientNetworkError(errorMsg)) {
+            const currentModelId = ctx.model?.id ?? "unknown";
+            const retryKey = `network-retry:${currentModelId}`;
+            const currentRetries = networkRetryCounters.get(retryKey) ?? 0;
+            const maxRetries = 2;
+            if (currentRetries < maxRetries) {
+                networkRetryCounters.set(retryKey, currentRetries + 1);
+                const attempt = currentRetries + 1;
+                const delayMs = attempt * 3000;
+                ctx.ui.notify(`Network error on ${currentModelId}${errorDetail}. Retry ${attempt}/${maxRetries} in ${delayMs / 1000}s...`, "warning");
+                setTimeout(() => {
+                    pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution — retrying after transient network error.", display: false }, { triggerTurn: true });
+                }, delayMs);
+                return;
+            }
+            networkRetryCounters.delete(retryKey);
+            ctx.ui.notify(`Network retries exhausted for ${currentModelId}. Attempting model fallback.`, "warning");
+        }
+        const dash = getAutoDashboardData();
+        if (dash.currentUnit) {
+            const modelConfig = resolveModelWithFallbacksForUnit(dash.currentUnit.type);
+            if (modelConfig && modelConfig.fallbacks.length > 0) {
+                const availableModels = ctx.modelRegistry.getAvailable();
+                const nextModelId = getNextFallbackModel(ctx.model?.id, modelConfig);
+                if (nextModelId) {
+                    networkRetryCounters.clear();
+                    const slashIdx = nextModelId.indexOf("/");
+                    const modelToSet = slashIdx !== -1
+                        ? availableModels.find((m) => m.provider.toLowerCase() === nextModelId.substring(0, slashIdx).toLowerCase() && m.id.toLowerCase() === nextModelId.substring(slashIdx + 1).toLowerCase())
+                        : (availableModels.find((m) => m.id === nextModelId && m.provider === ctx.model?.provider) ?? availableModels.find((m) => m.id === nextModelId));
+                    if (modelToSet) {
+                        const ok = await pi.setModel(modelToSet, { persist: false });
+                        if (ok) {
+                            ctx.ui.notify(`Model error${errorDetail}. Switched to fallback: ${nextModelId} and resuming.`, "warning");
+                            pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+        const sessionModel = getAutoModeStartModel();
+        if (sessionModel) {
+            if (ctx.model?.id !== sessionModel.id || ctx.model?.provider !== sessionModel.provider) {
+                const startModel = ctx.modelRegistry.getAvailable().find((m) => m.provider === sessionModel.provider && m.id === sessionModel.id);
+                if (startModel) {
+                    const ok = await pi.setModel(startModel, { persist: false });
+                    if (ok) {
+                        networkRetryCounters.clear();
+                        ctx.ui.notify(`Model error${errorDetail}. Restored session model: ${sessionModel.provider}/${sessionModel.id} and resuming.`, "warning");
+                        pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
+                        return;
+                    }
+                }
+            }
+        }
+        const classification = classifyProviderError(errorMsg);
+        const explicitRetryAfterMs = ("retryAfterMs" in lastMsg && typeof lastMsg.retryAfterMs === "number") ? lastMsg.retryAfterMs : undefined;
+        if (classification.isTransient) {
+            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: allowAutoResume,
+            retryAfterMs,
+            resume: allowAutoResume
+                ? () => {
+                    pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution — provider error recovery delay elapsed.", display: false }, { triggerTurn: true });
+                }
+                : undefined,
+        });
+        return;
+    }
+    try {
+        consecutiveTransientErrors = 0;
+        networkRetryCounters.clear();
+        resolveAgentEnd(event);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        ctx.ui.notify(`Auto-mode error in agent_end handler: ${message}. Stopping auto-mode.`, "error");
+        try {
+            await pauseAuto(ctx, pi);
+        }
+        catch {
+            // best-effort
+        }
+    }
+}

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

@@ -0,0 +1,233 @@
+import { Type } from "@sinclair/typebox";
+import { findMilestoneIds, nextMilestoneId } from "../guided-flow.js";
+import { loadEffectiveGSDPreferences } from "../preferences.js";
+import { ensureDbOpen } from "./dynamic-tools.js";
+export function registerDbTools(pi) {
+    pi.registerTool({
+        name: "gsd_save_decision",
+        label: "Save Decision",
+        description: "Record a project decision to the GSD database and regenerate DECISIONS.md. " +
+            "Decision IDs are auto-assigned — never provide an ID manually.",
+        promptSnippet: "Record a project decision to the GSD database (auto-assigns ID, regenerates DECISIONS.md)",
+        promptGuidelines: [
+            "Use gsd_save_decision when recording an architectural, pattern, library, or observability decision.",
+            "Decision IDs are auto-assigned (D001, D002, ...) — never guess or provide an ID.",
+            "All fields except revisable and when_context are required.",
+            "The tool writes to the DB and regenerates .gsd/DECISIONS.md automatically.",
+        ],
+        parameters: Type.Object({
+            scope: Type.String({ description: "Scope of the decision (e.g. 'architecture', 'library', 'observability')" }),
+            decision: Type.String({ description: "What is being decided" }),
+            choice: Type.String({ description: "The choice made" }),
+            rationale: Type.String({ description: "Why this choice was made" }),
+            revisable: Type.Optional(Type.String({ description: "Whether this can be revisited (default: 'Yes')" })),
+            when_context: Type.Optional(Type.String({ description: "When/context for the decision (e.g. milestone ID)" })),
+        }),
+        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            const dbAvailable = await ensureDbOpen();
+            if (!dbAvailable) {
+                return {
+                    content: [{ type: "text", text: "Error: GSD database is not available. Cannot save decision." }],
+                    details: { operation: "save_decision", error: "db_unavailable" },
+                };
+            }
+            try {
+                const { saveDecisionToDb } = await import("../db-writer.js");
+                const { id } = await saveDecisionToDb({
+                    scope: params.scope,
+                    decision: params.decision,
+                    choice: params.choice,
+                    rationale: params.rationale,
+                    revisable: params.revisable,
+                    when_context: params.when_context,
+                }, process.cwd());
+                return {
+                    content: [{ type: "text", text: `Saved decision ${id}` }],
+                    details: { operation: "save_decision", id },
+                };
+            }
+            catch (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", text: `Error saving decision: ${msg}` }],
+                    details: { operation: "save_decision", error: msg },
+                };
+            }
+        },
+    });
+    pi.registerTool({
+        name: "gsd_update_requirement",
+        label: "Update Requirement",
+        description: "Update an existing requirement in the GSD database and regenerate REQUIREMENTS.md. " +
+            "Provide the requirement ID (e.g. R001) and any fields to update.",
+        promptSnippet: "Update an existing GSD requirement by ID (regenerates REQUIREMENTS.md)",
+        promptGuidelines: [
+            "Use gsd_update_requirement to change status, validation, notes, or other fields on an existing requirement.",
+            "The id parameter is required — it must be an existing RXXX identifier.",
+            "All other fields are optional — only provided fields are updated.",
+            "The tool verifies the requirement exists before updating.",
+        ],
+        parameters: Type.Object({
+            id: Type.String({ description: "The requirement ID (e.g. R001, R014)" }),
+            status: Type.Optional(Type.String({ description: "New status (e.g. 'active', 'validated', 'deferred')" })),
+            validation: Type.Optional(Type.String({ description: "Validation criteria or proof" })),
+            notes: Type.Optional(Type.String({ description: "Additional notes" })),
+            description: Type.Optional(Type.String({ description: "Updated description" })),
+            primary_owner: Type.Optional(Type.String({ description: "Primary owning slice" })),
+            supporting_slices: Type.Optional(Type.String({ description: "Supporting slices" })),
+        }),
+        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            const dbAvailable = await ensureDbOpen();
+            if (!dbAvailable) {
+                return {
+                    content: [{ type: "text", text: "Error: GSD database is not available. Cannot update requirement." }],
+                    details: { operation: "update_requirement", id: params.id, error: "db_unavailable" },
+                };
+            }
+            try {
+                const db = await import("../gsd-db.js");
+                const existing = db.getRequirementById(params.id);
+                if (!existing) {
+                    return {
+                        content: [{ type: "text", text: `Error: Requirement ${params.id} not found.` }],
+                        details: { operation: "update_requirement", id: params.id, error: "not_found" },
+                    };
+                }
+                const { updateRequirementInDb } = await import("../db-writer.js");
+                const updates = {};
+                if (params.status !== undefined)
+                    updates.status = params.status;
+                if (params.validation !== undefined)
+                    updates.validation = params.validation;
+                if (params.notes !== undefined)
+                    updates.notes = params.notes;
+                if (params.description !== undefined)
+                    updates.description = params.description;
+                if (params.primary_owner !== undefined)
+                    updates.primary_owner = params.primary_owner;
+                if (params.supporting_slices !== undefined)
+                    updates.supporting_slices = params.supporting_slices;
+                await updateRequirementInDb(params.id, updates, process.cwd());
+                return {
+                    content: [{ type: "text", text: `Updated requirement ${params.id}` }],
+                    details: { operation: "update_requirement", id: params.id },
+                };
+            }
+            catch (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", text: `Error updating requirement: ${msg}` }],
+                    details: { operation: "update_requirement", id: params.id, error: msg },
+                };
+            }
+        },
+    });
+    pi.registerTool({
+        name: "gsd_save_summary",
+        label: "Save Summary",
+        description: "Save a summary, research, context, or assessment artifact to the GSD database and write it to disk. " +
+            "Computes the file path from milestone/slice/task IDs automatically.",
+        promptSnippet: "Save a GSD artifact (summary/research/context/assessment) to DB and disk",
+        promptGuidelines: [
+            "Use gsd_save_summary to persist structured artifacts (SUMMARY, RESEARCH, CONTEXT, ASSESSMENT).",
+            "milestone_id is required. slice_id and task_id are optional — they determine the file path.",
+            "The tool computes the relative path automatically: milestones/M001/M001-SUMMARY.md, milestones/M001/slices/S01/S01-SUMMARY.md, etc.",
+            "artifact_type must be one of: SUMMARY, RESEARCH, CONTEXT, ASSESSMENT.",
+        ],
+        parameters: Type.Object({
+            milestone_id: Type.String({ description: "Milestone ID (e.g. M001)" }),
+            slice_id: Type.Optional(Type.String({ description: "Slice ID (e.g. S01)" })),
+            task_id: Type.Optional(Type.String({ description: "Task ID (e.g. T01)" })),
+            artifact_type: Type.String({ description: "One of: SUMMARY, RESEARCH, CONTEXT, ASSESSMENT" }),
+            content: Type.String({ description: "The full markdown content of the artifact" }),
+        }),
+        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            const dbAvailable = await ensureDbOpen();
+            if (!dbAvailable) {
+                return {
+                    content: [{ type: "text", text: "Error: GSD database is not available. Cannot save artifact." }],
+                    details: { operation: "save_summary", error: "db_unavailable" },
+                };
+            }
+            const validTypes = ["SUMMARY", "RESEARCH", "CONTEXT", "ASSESSMENT"];
+            if (!validTypes.includes(params.artifact_type)) {
+                return {
+                    content: [{ type: "text", text: `Error: Invalid artifact_type "${params.artifact_type}". Must be one of: ${validTypes.join(", ")}` }],
+                    details: { operation: "save_summary", error: "invalid_artifact_type" },
+                };
+            }
+            try {
+                let relativePath;
+                if (params.task_id && params.slice_id) {
+                    relativePath = `milestones/${params.milestone_id}/slices/${params.slice_id}/tasks/${params.task_id}-${params.artifact_type}.md`;
+                }
+                else if (params.slice_id) {
+                    relativePath = `milestones/${params.milestone_id}/slices/${params.slice_id}/${params.slice_id}-${params.artifact_type}.md`;
+                }
+                else {
+                    relativePath = `milestones/${params.milestone_id}/${params.milestone_id}-${params.artifact_type}.md`;
+                }
+                const { saveArtifactToDb } = await import("../db-writer.js");
+                await saveArtifactToDb({
+                    path: relativePath,
+                    artifact_type: params.artifact_type,
+                    content: params.content,
+                    milestone_id: params.milestone_id,
+                    slice_id: params.slice_id,
+                    task_id: params.task_id,
+                }, process.cwd());
+                return {
+                    content: [{ type: "text", text: `Saved ${params.artifact_type} artifact to ${relativePath}` }],
+                    details: { operation: "save_summary", path: relativePath, artifact_type: params.artifact_type },
+                };
+            }
+            catch (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", text: `Error saving artifact: ${msg}` }],
+                    details: { operation: "save_summary", error: msg },
+                };
+            }
+        },
+    });
+    const reservedMilestoneIds = new Set();
+    pi.registerTool({
+        name: "gsd_generate_milestone_id",
+        label: "Generate Milestone ID",
+        description: "Generate the next milestone ID for a new GSD milestone. " +
+            "Scans existing milestones on disk and respects the unique_milestone_ids preference. " +
+            "Always use this tool when creating a new milestone — never invent milestone IDs manually.",
+        promptSnippet: "Generate a valid milestone ID (respects unique_milestone_ids preference)",
+        promptGuidelines: [
+            "ALWAYS call gsd_generate_milestone_id before creating a new milestone directory or writing milestone files.",
+            "Never invent or hardcode milestone IDs like M001, M002 — always use this tool.",
+            "Call it once per milestone you need to create. For multi-milestone projects, call it once for each milestone in sequence.",
+            "The tool returns the correct format based on project preferences (e.g. M001 or M001-r5jzab).",
+        ],
+        parameters: Type.Object({}),
+        async execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
+            try {
+                const basePath = process.cwd();
+                const existingIds = findMilestoneIds(basePath);
+                const uniqueEnabled = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
+                const allIds = [...new Set([...existingIds, ...reservedMilestoneIds])];
+                const newId = nextMilestoneId(allIds, uniqueEnabled);
+                reservedMilestoneIds.add(newId);
+                return {
+                    content: [{ type: "text", text: newId }],
+                    details: { operation: "generate_milestone_id", id: newId, existingCount: existingIds.length, reservedCount: reservedMilestoneIds.size, uniqueEnabled },
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return {
+                    content: [{ type: "text", text: `Error generating milestone ID: ${msg}` }],
+                    details: { operation: "generate_milestone_id", error: msg },
+                };
+            }
+        },
+    });
+}