gsd-pi 2.67.0-dev.1cd1e0f → 2.67.0-dev.2367d7e

package/dist/resources/extensions/gsd/init-wizard.js

@@ -187,6 +187,16 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
     }
     // ── Step 9: Bootstrap .gsd/ ────────────────────────────────────────────────
     bootstrapGsdDirectory(basePath, prefs, signals);
+    // Initialize SQLite database so GSD starts in full-capability mode (#3880).
+    // Without this, isDbAvailable() returns false and GSD enters degraded
+    // markdown-only mode until a tool handler happens to call ensureDbOpen().
+    try {
+        const { ensureDbOpen } = await import("./bootstrap/dynamic-tools.js");
+        await ensureDbOpen(basePath);
+    }
+    catch {
+        // Non-fatal — DB creation failure should not block project init
+    }
     // Ensure .gitignore
     ensureGitignore(basePath);
     untrackRuntimeFiles(basePath);
@@ -201,6 +211,32 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
     catch {
         // Non-fatal — codebase map generation failure should never block project init
     }
+    // Write initial STATE.md so it exists before the first /gsd invocation.
+    // The explicit /gsd init path (ops.ts) returns without entering showSmartEntry(),
+    // which would otherwise generate STATE.md at guided-flow.ts:1358.
+    try {
+        const { deriveState } = await import("./state.js");
+        const { buildStateMarkdown } = await import("./doctor.js");
+        const { saveFile } = await import("./files.js");
+        const { resolveGsdRootFile } = await import("./paths.js");
+        const state = await deriveState(basePath);
+        await saveFile(resolveGsdRootFile(basePath, "STATE"), buildStateMarkdown(state));
+    }
+    catch {
+        // Non-fatal — STATE.md will be regenerated on next /gsd invocation
+    }
+    if (ctx.model?.provider === "claude-code") {
+        try {
+            const { ensureProjectWorkflowMcpConfig } = await import("./mcp-project-config.js");
+            const result = ensureProjectWorkflowMcpConfig(basePath);
+            if (result.status !== "unchanged") {
+                ctx.ui.notify(`Claude Code MCP prepared at ${result.configPath}`, "info");
+            }
+        }
+        catch (err) {
+            ctx.ui.notify(`Claude Code MCP prep failed: ${err instanceof Error ? err.message : String(err)}`, "warning");
+        }
+    }
     ctx.ui.notify("GSD initialized. Starting your first milestone...", "info");
     return { completed: true, bootstrapped: true };
 }
@@ -348,6 +384,7 @@ function bootstrapGsdDirectory(basePath, prefs, signals) {
     assertSafeDirectory(basePath);
     const gsd = gsdRoot(basePath);
     mkdirSync(join(gsd, "milestones"), { recursive: true });
+    mkdirSync(join(gsd, "runtime"), { recursive: true });
     // Write PREFERENCES.md from wizard answers
     const preferencesContent = buildPreferencesFile(prefs);
     writeFileSync(join(gsd, "PREFERENCES.md"), preferencesContent, "utf-8");

package/dist/resources/extensions/gsd/interrupted-session.js

@@ -0,0 +1,146 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { verifyExpectedArtifact } from "./auto-recovery.js";
+import { formatCrashInfo, isLockProcessAlive, readCrashLock, } from "./crash-recovery.js";
+import { gsdRoot } from "./paths.js";
+import { synthesizeCrashRecovery, } from "./session-forensics.js";
+import { deriveState } from "./state.js";
+export function readPausedSessionMetadata(basePath) {
+    const pausedPath = join(gsdRoot(basePath), "runtime", "paused-session.json");
+    if (!existsSync(pausedPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(pausedPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function isBootstrapCrashLock(lock) {
+    return !!(lock &&
+        lock.unitType === "starting" &&
+        lock.unitId === "bootstrap");
+}
+export function hasResumableDerivedState(state) {
+    return !!(state?.activeMilestone && state.phase !== "complete");
+}
+export async function assessInterruptedSession(basePath) {
+    const pausedSession = readPausedSessionMetadata(basePath);
+    const worktreeExists = pausedSession?.worktreePath
+        ? existsSync(pausedSession.worktreePath)
+        : false;
+    const assessmentBasePath = worktreeExists ? pausedSession.worktreePath : basePath;
+    const rawLock = readCrashLock(basePath);
+    const lock = rawLock && rawLock.pid !== process.pid ? rawLock : null;
+    if (!lock && !pausedSession) {
+        return {
+            classification: "none",
+            lock: null,
+            pausedSession: null,
+            state: null,
+            recovery: null,
+            recoveryPrompt: null,
+            recoveryToolCallCount: 0,
+            artifactSatisfied: false,
+            hasResumableDiskState: false,
+            isBootstrapCrash: false,
+        };
+    }
+    if (lock && isLockProcessAlive(lock)) {
+        return {
+            classification: "running",
+            lock,
+            pausedSession,
+            state: null,
+            recovery: null,
+            recoveryPrompt: null,
+            recoveryToolCallCount: 0,
+            artifactSatisfied: false,
+            hasResumableDiskState: false,
+            isBootstrapCrash: false,
+        };
+    }
+    const isBootstrapCrash = isBootstrapCrashLock(lock);
+    const state = await deriveState(assessmentBasePath);
+    const hasResumableDiskState = hasResumableDerivedState(state);
+    const artifactSatisfied = !!(lock &&
+        !isBootstrapCrash &&
+        verifyExpectedArtifact(lock.unitType, lock.unitId, assessmentBasePath));
+    let recovery = null;
+    if (lock && !isBootstrapCrash && !artifactSatisfied) {
+        recovery = synthesizeCrashRecovery(assessmentBasePath, lock.unitType, lock.unitId, lock.sessionFile, join(gsdRoot(assessmentBasePath), "activity"));
+    }
+    const recoveryToolCallCount = recovery?.trace.toolCallCount ?? 0;
+    const recoveryPrompt = recoveryToolCallCount > 0 ? recovery.prompt : null;
+    if (isBootstrapCrash) {
+        return {
+            classification: pausedSession ? "recoverable" : "stale",
+            lock,
+            pausedSession,
+            state,
+            recovery,
+            recoveryPrompt,
+            recoveryToolCallCount,
+            artifactSatisfied,
+            hasResumableDiskState,
+            isBootstrapCrash: true,
+        };
+    }
+    if (!hasResumableDiskState && pausedSession && !lock && recoveryToolCallCount === 0) {
+        return {
+            classification: "stale",
+            lock,
+            pausedSession,
+            state,
+            recovery,
+            recoveryPrompt,
+            recoveryToolCallCount,
+            artifactSatisfied,
+            hasResumableDiskState,
+            isBootstrapCrash: false,
+        };
+    }
+    if (lock && artifactSatisfied && !hasResumableDiskState && recoveryToolCallCount === 0) {
+        return {
+            classification: "stale",
+            lock,
+            pausedSession,
+            state,
+            recovery,
+            recoveryPrompt,
+            recoveryToolCallCount,
+            artifactSatisfied,
+            hasResumableDiskState,
+            isBootstrapCrash: false,
+        };
+    }
+    const hasStrongRecoverySignal = hasResumableDiskState || recoveryToolCallCount > 0;
+    return {
+        classification: hasStrongRecoverySignal ? "recoverable" : "stale",
+        lock,
+        pausedSession,
+        state,
+        recovery,
+        recoveryPrompt,
+        recoveryToolCallCount,
+        artifactSatisfied,
+        hasResumableDiskState,
+        isBootstrapCrash: false,
+    };
+}
+export function formatInterruptedSessionSummary(assessment) {
+    if (assessment.lock)
+        return [formatCrashInfo(assessment.lock)];
+    if (assessment.pausedSession?.milestoneId) {
+        return [
+            `Paused auto-mode session detected for ${assessment.pausedSession.milestoneId}.`,
+        ];
+    }
+    return ["Paused auto-mode session detected."];
+}
+export function formatInterruptedSessionRunningMessage(assessment) {
+    const pid = assessment.lock?.pid;
+    return pid
+        ? `Another auto-mode session (PID ${pid}) appears to be running.\nStop it with \`kill ${pid}\` before starting a new session.`
+        : "Another auto-mode session appears to be running.";
+}

package/dist/resources/extensions/gsd/mcp-project-config.js

@@ -0,0 +1,83 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { assertSafeDirectory } from "./validate-directory.js";
+import { detectWorkflowMcpLaunchConfig } from "./workflow-mcp.js";
+export const GSD_WORKFLOW_MCP_SERVER_NAME = "gsd-workflow";
+export function resolveBundledGsdCliPath(env = process.env) {
+    const explicit = env.GSD_CLI_PATH?.trim() || env.GSD_BIN_PATH?.trim();
+    if (explicit)
+        return explicit;
+    const candidates = [
+        resolve(fileURLToPath(new URL("../../../../scripts/dev-cli.js", import.meta.url))),
+        resolve(fileURLToPath(new URL("../../../../dist/loader.js", import.meta.url))),
+        resolve(fileURLToPath(new URL("../../../loader.js", import.meta.url))),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+export function buildProjectWorkflowMcpServerConfig(projectRoot, env = process.env) {
+    const resolvedProjectRoot = resolve(projectRoot);
+    const gsdCliPath = resolveBundledGsdCliPath(env);
+    const launch = detectWorkflowMcpLaunchConfig(resolvedProjectRoot, {
+        ...env,
+        ...(gsdCliPath ? { GSD_CLI_PATH: gsdCliPath, GSD_BIN_PATH: gsdCliPath } : {}),
+    });
+    if (!launch) {
+        throw new Error("Unable to resolve the GSD workflow MCP server. Build this checkout or install gsd-mcp-server on PATH.");
+    }
+    return {
+        command: launch.command,
+        ...(launch.args && launch.args.length > 0 ? { args: launch.args } : {}),
+        ...(launch.cwd ? { cwd: launch.cwd } : {}),
+        ...(launch.env ? { env: launch.env } : {}),
+    };
+}
+function readExistingConfig(configPath) {
+    if (!existsSync(configPath))
+        return {};
+    const raw = readFileSync(configPath, "utf-8");
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch (err) {
+        throw new Error(`Failed to parse ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+export function ensureProjectWorkflowMcpConfig(projectRoot, env = process.env) {
+    const resolvedProjectRoot = resolve(projectRoot);
+    assertSafeDirectory(resolvedProjectRoot);
+    const configPath = resolve(resolvedProjectRoot, ".mcp.json");
+    const existing = readExistingConfig(configPath);
+    const desiredServer = buildProjectWorkflowMcpServerConfig(resolvedProjectRoot, env);
+    const previousServers = existing.mcpServers ?? {};
+    const nextServers = {
+        ...previousServers,
+        [GSD_WORKFLOW_MCP_SERVER_NAME]: desiredServer,
+    };
+    const alreadyPresent = existsSync(configPath);
+    const unchanged = JSON.stringify(previousServers[GSD_WORKFLOW_MCP_SERVER_NAME] ?? null)
+        === JSON.stringify(desiredServer)
+        && existing.mcpServers !== undefined;
+    if (unchanged) {
+        return {
+            configPath,
+            serverName: GSD_WORKFLOW_MCP_SERVER_NAME,
+            status: "unchanged",
+        };
+    }
+    const nextConfig = {
+        ...existing,
+        mcpServers: nextServers,
+    };
+    writeFileSync(configPath, `${JSON.stringify(nextConfig, null, 2)}\n`, "utf-8");
+    return {
+        configPath,
+        serverName: GSD_WORKFLOW_MCP_SERVER_NAME,
+        status: alreadyPresent ? "updated" : "created",
+    };
+}

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

@@ -13,7 +13,7 @@ import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { debugCount, debugTime } from './debug-logger.js';
 import { logWarning, logError } from './workflow-logger.js';
 import { extractVerdict } from './verdict-parser.js';
-import { isDbAvailable, getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, insertSlice, insertTask, updateTaskStatus, getPendingSliceGateCount, } from './gsd-db.js';
+import { isDbAvailable, wasDbOpenAttempted, getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, insertSlice, insertTask, updateTaskStatus, getPendingSliceGateCount, } from './gsd-db.js';
 /**
  * A "ghost" milestone directory contains only META.json (and no substantive
  * files like CONTEXT, CONTEXT-DRAFT, ROADMAP, or SUMMARY).  These appear when
@@ -200,7 +200,12 @@ export async function deriveState(basePath) {
         }
     }
     else {
-        logWarning("state", "DB unavailable — using filesystem state derivation (degraded mode)");
+        // Only warn when DB initialization was attempted and failed — not when
+        // the DB simply hasn't been opened yet (e.g. during before_agent_start
+        // context injection which runs before any tool invocation opens the DB).
+        if (wasDbOpenAttempted()) {
+            logWarning("state", "DB unavailable — using filesystem state derivation (degraded mode)");
+        }
         result = await _deriveStateImpl(basePath);
         _telemetry.markdownDeriveCount++;
     }