gsd-pi 2.67.0-dev.5399650 → 2.67.0-dev.6fc2289

package/src/resources/extensions/gsd/init-wizard.ts

@@ -238,15 +238,11 @@ export async function showProjectInit(
   // 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().
-  let dbReady = false;
   try {
     const { ensureDbOpen } = await import("./bootstrap/dynamic-tools.js");
-    dbReady = await ensureDbOpen(basePath);
+    await ensureDbOpen(basePath);
   } catch {
-    // Swallowed — warning surfaced below
-  }
-  if (!dbReady) {
-    ctx.ui.notify("Warning: database initialization failed — GSD will run in degraded mode until the next /gsd invocation.", "warning");
+    // Non-fatal — DB creation failure should not block project init
   }
 
   // Ensure .gitignore
@@ -267,7 +263,6 @@ export async function showProjectInit(
   // 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.
-  let stateReady = false;
   try {
     const { deriveState } = await import("./state.js");
     const { buildStateMarkdown } = await import("./doctor.js");
@@ -275,12 +270,23 @@ export async function showProjectInit(
     const { resolveGsdRootFile } = await import("./paths.js");
     const state = await deriveState(basePath);
     await saveFile(resolveGsdRootFile(basePath, "STATE"), buildStateMarkdown(state));
-    stateReady = true;
   } catch {
-    // Swallowed — warning surfaced below
+    // Non-fatal — STATE.md will be regenerated on next /gsd invocation
   }
-  if (!stateReady) {
-    ctx.ui.notify("Warning: initial STATE.md generation failed — it will be created on the next /gsd invocation.", "warning");
+
+  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");

package/src/resources/extensions/gsd/interrupted-session.ts

@@ -0,0 +1,224 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { verifyExpectedArtifact } from "./auto-recovery.js";
+import {
+  formatCrashInfo,
+  isLockProcessAlive,
+  readCrashLock,
+  type LockData,
+} from "./crash-recovery.js";
+import { gsdRoot } from "./paths.js";
+import {
+  synthesizeCrashRecovery,
+  type RecoveryBriefing,
+} from "./session-forensics.js";
+import { deriveState } from "./state.js";
+import type { GSDState } from "./types.js";
+
+export type InterruptedSessionClassification =
+  | "none"
+  | "running"
+  | "recoverable"
+  | "stale";
+
+export interface PausedSessionMetadata {
+  milestoneId?: string;
+  worktreePath?: string | null;
+  originalBasePath?: string;
+  stepMode?: boolean;
+  pausedAt?: string;
+  sessionFile?: string | null;
+  unitType?: string;
+  unitId?: string;
+  activeEngineId?: string;
+  activeRunDir?: string | null;
+  autoStartTime?: number;
+}
+
+export interface InterruptedSessionAssessment {
+  classification: InterruptedSessionClassification;
+  lock: LockData | null;
+  pausedSession: PausedSessionMetadata | null;
+  state: GSDState | null;
+  recovery: RecoveryBriefing | null;
+  recoveryPrompt: string | null;
+  recoveryToolCallCount: number;
+  artifactSatisfied: boolean;
+  hasResumableDiskState: boolean;
+  isBootstrapCrash: boolean;
+}
+
+export function readPausedSessionMetadata(
+  basePath: string,
+): PausedSessionMetadata | null {
+  const pausedPath = join(gsdRoot(basePath), "runtime", "paused-session.json");
+  if (!existsSync(pausedPath)) return null;
+
+  try {
+    return JSON.parse(readFileSync(pausedPath, "utf-8")) as PausedSessionMetadata;
+  } catch {
+    return null;
+  }
+}
+
+export function isBootstrapCrashLock(lock: LockData | null): boolean {
+  return !!(
+    lock &&
+    lock.unitType === "starting" &&
+    lock.unitId === "bootstrap"
+  );
+}
+
+export function hasResumableDerivedState(state: GSDState | null): boolean {
+  return !!(state?.activeMilestone && state.phase !== "complete");
+}
+
+export async function assessInterruptedSession(
+  basePath: string,
+): Promise<InterruptedSessionAssessment> {
+  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: RecoveryBriefing | null = 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: InterruptedSessionAssessment,
+): string[] {
+  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: InterruptedSessionAssessment,
+): string {
+  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/src/resources/extensions/gsd/mcp-project-config.ts

@@ -0,0 +1,128 @@
+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 interface ProjectMcpServerConfig {
+  command?: string;
+  args?: string[];
+  cwd?: string;
+  env?: Record<string, string>;
+  url?: string;
+}
+
+export interface EnsureProjectWorkflowMcpConfigResult {
+  configPath: string;
+  serverName: string;
+  status: "created" | "updated" | "unchanged";
+}
+
+interface McpConfigFile {
+  mcpServers?: Record<string, ProjectMcpServerConfig>;
+  servers?: Record<string, ProjectMcpServerConfig>;
+  [key: string]: unknown;
+}
+
+export function resolveBundledGsdCliPath(env: NodeJS.ProcessEnv = process.env): string | null {
+  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: string,
+  env: NodeJS.ProcessEnv = process.env,
+): ProjectMcpServerConfig {
+  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: string): McpConfigFile {
+  if (!existsSync(configPath)) return {};
+
+  const raw = readFileSync(configPath, "utf-8");
+  try {
+    const parsed = JSON.parse(raw) as McpConfigFile;
+    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: string,
+  env: NodeJS.ProcessEnv = process.env,
+): EnsureProjectWorkflowMcpConfigResult {
+  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: McpConfigFile = {
+    ...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",
+  };
+}