gsd-pi 2.74.0 → 2.75.0-dev.fd2382b9f

package/src/resources/extensions/gsd/workflow-install.ts

@@ -0,0 +1,423 @@
+/**
+ * workflow-install.ts — Fetch, validate, and install remote workflow plugins.
+ *
+ * Accepts:
+ *   - Full URL (https://raw.githubusercontent.com/... or gist raw URL)
+ *   - gist:abc123           → https://gist.githubusercontent.com/anonymous/abc123/raw
+ *   - gh:owner/repo/path[@ref] → raw.githubusercontent.com/owner/repo/<ref>/path
+ *
+ * Installed files land in `~/.gsd/workflows/<name>.<ext>` by default, or
+ * `.gsd/workflows/<name>.<ext>` with the `--project` flag.
+ *
+ * A provenance file `~/.gsd/workflows/.installed.json` (or project equivalent)
+ * records source URL, timestamp, and sha256 so `/gsd workflow uninstall` can
+ * clean up and future `/gsd workflow update` can refresh.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { extname, join, resolve, sep as pathSep } from "node:path";
+import { createHash } from "node:crypto";
+import { parse as parseYaml } from "yaml";
+
+import { validateDefinition } from "./definition-loader.js";
+
+// ─── Constants ───────────────────────────────────────────────────────────
+
+const MAX_RESPONSE_BYTES = 256 * 1024;
+const FETCH_TIMEOUT_MS = 15_000;
+const PROVENANCE_FILE = ".installed.json";
+
+// ─── Provenance ──────────────────────────────────────────────────────────
+
+export interface ProvenanceEntry {
+  source: string;
+  installedAt: string;
+  sha256: string;
+  filename: string;
+}
+
+type Provenance = Record<string, ProvenanceEntry>;
+
+function provenancePath(dir: string): string {
+  return join(dir, PROVENANCE_FILE);
+}
+
+function readProvenance(dir: string): Provenance {
+  const path = provenancePath(dir);
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf-8")) as Provenance;
+  } catch {
+    return {};
+  }
+}
+
+function writeProvenance(dir: string, data: Provenance): void {
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(provenancePath(dir), JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+
+// ─── Install targets ─────────────────────────────────────────────────────
+
+export interface InstallTarget {
+  dir: string;
+  scope: "global" | "project";
+}
+
+export function globalInstallDir(): string {
+  const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
+  return join(gsdHome, "workflows");
+}
+
+export function projectInstallDir(basePath: string): string {
+  return join(basePath, ".gsd", "workflows");
+}
+
+/**
+ * Reject plugin names that could escape the workflows directory.
+ * Allows a-z, A-Z, 0-9, dot, underscore, hyphen — no separators, no dot-segments.
+ */
+function assertSafePluginName(name: string): void {
+  if (!name || name === "." || name === "..") {
+    throw new Error(`Invalid plugin name: "${name}"`);
+  }
+  if (!/^[a-zA-Z0-9._-]+$/.test(name)) {
+    throw new Error(
+      `Invalid plugin name "${name}". Allowed characters: letters, digits, dot, underscore, hyphen.`,
+    );
+  }
+}
+
+/**
+ * Resolve `child` inside `dir` and refuse any result that escapes `dir`.
+ */
+function safeResolveInDir(dir: string, child: string): string {
+  const resolvedDir = resolve(dir);
+  const resolvedPath = resolve(resolvedDir, child);
+  if (
+    resolvedPath !== resolvedDir &&
+    !resolvedPath.startsWith(resolvedDir + pathSep)
+  ) {
+    throw new Error(`Refusing to operate outside ${dir}: ${child}`);
+  }
+  return resolvedPath;
+}
+
+// ─── Source URL resolution ───────────────────────────────────────────────
+
+/**
+ * Turn a user-supplied source specifier into a fetchable HTTPS URL.
+ * Throws on clearly unsafe inputs (file://, unsupported schemes).
+ */
+export function resolveSourceUrl(source: string): string {
+  const trimmed = source.trim();
+
+  // gist:<id>
+  if (trimmed.startsWith("gist:")) {
+    const id = trimmed.slice("gist:".length).trim();
+    if (!/^[a-f0-9]{6,}$/i.test(id)) {
+      throw new Error(`Invalid gist id: ${id}`);
+    }
+    return `https://gist.githubusercontent.com/anonymous/${id}/raw`;
+  }
+
+  // gh:owner/repo/path[@ref]
+  if (trimmed.startsWith("gh:")) {
+    const rest = trimmed.slice("gh:".length);
+    const atIdx = rest.lastIndexOf("@");
+    const pathPart = atIdx === -1 ? rest : rest.slice(0, atIdx);
+    const ref = atIdx === -1 ? "main" : rest.slice(atIdx + 1);
+    const parts = pathPart.split("/");
+    if (parts.length < 3) {
+      throw new Error(`Expected gh:<owner>/<repo>/<path>: ${trimmed}`);
+    }
+    const [owner, repo, ...filePath] = parts;
+    return `https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${filePath.join("/")}`;
+  }
+
+  // file:// — reject
+  if (trimmed.startsWith("file:")) {
+    throw new Error("file:// sources are not supported for security reasons.");
+  }
+
+  // Must be https:// (or http://localhost for dev)
+  if (trimmed.startsWith("https://")) return trimmed;
+  if (trimmed.startsWith("http://")) {
+    const url = new URL(trimmed);
+    if (url.hostname === "localhost" || url.hostname === "127.0.0.1") {
+      return trimmed;
+    }
+    throw new Error("http:// is only allowed for localhost. Use https://.");
+  }
+
+  throw new Error(
+    `Unsupported source format: ${trimmed}\n` +
+    `Use one of: https://..., gist:<id>, gh:<owner>/<repo>/<path>[@ref]`,
+  );
+}
+
+// ─── Fetching ────────────────────────────────────────────────────────────
+
+export interface FetchedContent {
+  url: string;
+  filename: string;
+  ext: ".yaml" | ".yml" | ".md";
+  content: string;
+  sha256: string;
+}
+
+/**
+ * Fetch the resolved URL with a timeout and a max response size.
+ * Injects a simple User-Agent so GitHub doesn't 403.
+ */
+export async function fetchWorkflowSource(url: string): Promise<FetchedContent> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+
+  try {
+    const res = await fetch(url, {
+      signal: controller.signal,
+      headers: { "User-Agent": "gsd-workflow-install" },
+    });
+
+    if (!res.ok) {
+      throw new Error(`Fetch failed (${res.status} ${res.statusText}): ${url}`);
+    }
+
+    // Cap size: read as a stream and bail if it exceeds MAX_RESPONSE_BYTES.
+    const buf = await res.arrayBuffer();
+    if (buf.byteLength > MAX_RESPONSE_BYTES) {
+      throw new Error(
+        `Response too large (${buf.byteLength} bytes, max ${MAX_RESPONSE_BYTES}): ${url}`,
+      );
+    }
+
+    const content = new TextDecoder().decode(buf);
+
+    // Prefer the final response URL after redirects (e.g., gist /raw → /raw/<sha>/file.ext).
+    const finalUrl = typeof res.url === "string" && res.url ? res.url : url;
+    let pathname: string;
+    try {
+      pathname = new URL(finalUrl).pathname;
+    } catch {
+      pathname = new URL(url).pathname;
+    }
+    let basename = pathname.slice(pathname.lastIndexOf("/") + 1);
+    let rawExt = extname(basename).toLowerCase();
+
+    let ext: ".yaml" | ".yml" | ".md";
+    if (rawExt === ".yaml" || rawExt === ".yml" || rawExt === ".md") {
+      ext = rawExt;
+    } else {
+      // Fallback: sniff content. Gist /raw and similar URLs have no extension.
+      if (/<template_meta>[\s\S]*?<\/template_meta>/.test(content)) {
+        ext = ".md";
+      } else {
+        let parsed: unknown;
+        try {
+          parsed = parseYaml(content);
+        } catch {
+          parsed = undefined;
+        }
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          ext = ".yaml";
+        } else {
+          throw new Error(
+            `Cannot determine workflow type from ${url}. ` +
+            `Expected .yaml/.yml/.md URL, a markdown file with <template_meta>, ` +
+            `or a YAML document.`,
+          );
+        }
+      }
+      // Synthesize a filename so downstream sanitizers have something to chew on.
+      if (!basename) basename = "workflow";
+      basename = `${basename}${ext}`;
+    }
+
+    const filename = basename;
+    const sha256 = createHash("sha256").update(content).digest("hex");
+
+    return { url, filename, ext, content, sha256 };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// ─── Validation ──────────────────────────────────────────────────────────
+
+/**
+ * Validate fetched content: YAML must pass validateDefinition, markdown must
+ * have a `<template_meta>` block with at least `name`.
+ */
+export function validateFetchedContent(fetched: FetchedContent): void {
+  if (fetched.ext === ".yaml" || fetched.ext === ".yml") {
+    let parsed: unknown;
+    try {
+      parsed = parseYaml(fetched.content);
+    } catch (err) {
+      throw new Error(
+        `Installed YAML failed to parse: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+    const result = validateDefinition(parsed);
+    if (!result.valid) {
+      throw new Error(
+        `Installed YAML failed validation:\n  - ${result.errors.join("\n  - ")}`,
+      );
+    }
+    // Optional: validate `mode:` if present.
+    if (parsed && typeof parsed === "object") {
+      const mode = (parsed as Record<string, unknown>).mode;
+      if (mode !== undefined && mode !== "oneshot" && mode !== "yaml-step") {
+        throw new Error(
+          `YAML plugins must declare mode: oneshot or yaml-step (got "${String(mode)}")`,
+        );
+      }
+    }
+    return;
+  }
+
+  // Markdown: require a <template_meta> block with at least a name.
+  const metaMatch = fetched.content.match(/<template_meta>([\s\S]*?)<\/template_meta>/);
+  if (!metaMatch) {
+    throw new Error("Installed markdown must contain a <template_meta>…</template_meta> block.");
+  }
+  if (!/\bname\s*:/i.test(metaMatch[1])) {
+    throw new Error("Installed markdown <template_meta> must declare at least `name:`.");
+  }
+  // Optional: validate `mode:` if declared.
+  const modeLine = metaMatch[1].match(/\bmode\s*:\s*(\S+)/i);
+  if (modeLine) {
+    const mode = modeLine[1];
+    if (mode !== "oneshot" && mode !== "markdown-phase") {
+      throw new Error(
+        `Markdown plugins must declare mode: oneshot or markdown-phase (got "${mode}")`,
+      );
+    }
+  }
+}
+
+// ─── Name inference ──────────────────────────────────────────────────────
+
+/**
+ * Infer a plugin name from fetched content. For YAML, prefer the top-level
+ * `name:` field. For markdown, prefer `<template_meta>.name`. Fall back to
+ * the filename stem.
+ */
+export function inferPluginName(fetched: FetchedContent): string {
+  if (fetched.ext === ".yaml" || fetched.ext === ".yml") {
+    try {
+      const parsed = parseYaml(fetched.content);
+      if (parsed && typeof parsed === "object") {
+        const n = (parsed as Record<string, unknown>).name;
+        if (typeof n === "string" && n.trim()) return sanitizeName(n);
+      }
+    } catch {
+      // Fall through to filename.
+    }
+  } else {
+    const metaMatch = fetched.content.match(/<template_meta>([\s\S]*?)<\/template_meta>/);
+    if (metaMatch) {
+      const nameMatch = metaMatch[1].match(/\bname\s*:\s*(\S+)/i);
+      if (nameMatch) return sanitizeName(nameMatch[1]);
+    }
+  }
+  const stem = fetched.filename.replace(/\.[^.]+$/, "");
+  return sanitizeName(stem);
+}
+
+function sanitizeName(raw: string): string {
+  return raw.trim().toLowerCase().replace(/[^a-z0-9._-]/g, "-").replace(/^-+|-+$/g, "");
+}
+
+// ─── Install / uninstall ─────────────────────────────────────────────────
+
+export interface InstallResult {
+  path: string;
+  name: string;
+  ext: ".yaml" | ".yml" | ".md";
+  source: string;
+}
+
+/**
+ * Write the fetched plugin to disk and update the provenance file.
+ * Does NOT prompt — caller is responsible for confirming with the user first.
+ */
+export function installPlugin(
+  target: InstallTarget,
+  fetched: FetchedContent,
+  name: string,
+): InstallResult {
+  assertSafePluginName(name);
+  mkdirSync(target.dir, { recursive: true });
+  const filename = `${name}${fetched.ext}`;
+  const path = safeResolveInDir(target.dir, filename);
+  writeFileSync(path, fetched.content, "utf-8");
+
+  const prov = readProvenance(target.dir);
+  prov[name] = {
+    source: fetched.url,
+    installedAt: new Date().toISOString(),
+    sha256: fetched.sha256,
+    filename,
+  };
+  writeProvenance(target.dir, prov);
+
+  return { path, name, ext: fetched.ext, source: fetched.url };
+}
+
+export interface UninstallResult {
+  removed: boolean;
+  path?: string;
+  warnedNotInProvenance?: boolean;
+}
+
+/**
+ * Remove an installed plugin and its provenance record.
+ * Checks global dir first, then project (same order as install default).
+ */
+export function uninstallPlugin(basePath: string, name: string): UninstallResult {
+  assertSafePluginName(name);
+  for (const dir of [globalInstallDir(), projectInstallDir(basePath)]) {
+    const prov = readProvenance(dir);
+    const entry = prov[name];
+    if (entry) {
+      // Re-validate the filename recorded in provenance: a malicious provenance
+      // file must not trick us into deleting outside `dir`.
+      assertSafePluginName(entry.filename.replace(/\.(yaml|yml|md)$/i, ""));
+      const path = safeResolveInDir(dir, entry.filename);
+      if (existsSync(path)) unlinkSync(path);
+      delete prov[name];
+      writeProvenance(dir, prov);
+      return { removed: true, path };
+    }
+
+    // No provenance, but file might still exist.
+    for (const ext of [".yaml", ".yml", ".md"]) {
+      const candidate = safeResolveInDir(dir, `${name}${ext}`);
+      if (existsSync(candidate) && statSync(candidate).isFile()) {
+        unlinkSync(candidate);
+        return { removed: true, path: candidate, warnedNotInProvenance: true };
+      }
+    }
+  }
+  return { removed: false };
+}
+
+// ─── Preview helpers ─────────────────────────────────────────────────────
+
+/**
+ * First N lines of the fetched content, for the install confirmation UI.
+ */
+export function previewContent(content: string, maxLines = 20): string {
+  const lines = content.split(/\r?\n/).slice(0, maxLines);
+  return lines.join("\n");
+}

package/src/resources/extensions/gsd/workflow-logger.ts

@@ -20,6 +20,8 @@ import { appendFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 
 import { appendNotification } from "./notification-store.js";
+import { buildAuditEnvelope, emitUokAuditEvent } from "./uok/audit.js";
+import { isUnifiedAuditEnabled } from "./uok/audit-toggle.js";
 
 // ─── Types ──────────────────────────────────────────────────────────────
 
@@ -51,7 +53,8 @@ export type LogComponent =
   | "guided"        // Guided flow (discuss, plan wizards)
   | "registry"      // Rule registry hook state
   | "renderer"      // Markdown renderer and projections
-  | "safety";       // LLM safety harness
+  | "safety"        // LLM safety harness
+  | "ecosystem";    // GSD ecosystem extension loader and dispatch
 
 export interface LogEntry {
   ts: string;
@@ -275,6 +278,29 @@ function _push(
     _buffer.shift();
   }
 
+  if (_auditBasePath && isUnifiedAuditEnabled()) {
+    try {
+      emitUokAuditEvent(
+        _auditBasePath,
+        buildAuditEnvelope({
+          traceId: `workflow-log:${component}`,
+          turnId: context?.id,
+          causedBy: context?.fn ?? context?.tool,
+          category: "orchestration",
+          type: severity === "error" ? "workflow-log-error" : "workflow-log-warn",
+          payload: {
+            component,
+            message,
+            context: context ?? {},
+          },
+        }),
+      );
+    } catch (auditEmitErr) {
+      // Best-effort: unified audit projection must never block workflow logger.
+      _writeStderr(`[gsd:workflow-logger] unified-audit emit failed: ${(auditEmitErr as Error).message}\n`);
+    }
+  }
+
   // Persist errors to .gsd/audit-log.jsonl so they survive context resets.
   // Only error-severity entries are persisted — warnings are ephemeral (stderr + buffer)
   // to avoid log amplification from expected-control-flow catch paths.

package/src/resources/extensions/gsd/workflow-manifest.ts

@@ -1,6 +1,7 @@
 import {
   _getAdapter,
-  transaction,
+  readTransaction,
+  restoreManifest,
   type MilestoneRow,
   type SliceRow,
   type TaskRow,
@@ -74,9 +75,7 @@ export function snapshotState(): StateManifest {
 
   // Wrap all reads in a deferred transaction so the snapshot is consistent
   // (all SELECTs see the same DB state even if a concurrent write lands between them).
-  db.exec("BEGIN DEFERRED");
-
-  try {
+  return readTransaction(() => {
   const rawMilestones = db.prepare("SELECT * FROM milestones ORDER BY id").all() as Record<string, unknown>[];
   const milestones: MilestoneRow[] = rawMilestones.map((r) => ({
     id: r["id"] as string,
@@ -118,6 +117,8 @@ export function snapshotState(): StateManifest {
     observability_impact: (r["observability_impact"] as string) ?? "",
     sequence: toNumeric(r["sequence"], 0) as number,
     replan_triggered_at: (r["replan_triggered_at"] as string) ?? null,
+    is_sketch: toNumeric(r["is_sketch"], 0) as number,
+    sketch_scope: (r["sketch_scope"] as string) ?? "",
   }));
 
   const rawTasks = db.prepare("SELECT * FROM tasks ORDER BY milestone_id, slice_id, sequence, id").all() as Record<string, unknown>[];
@@ -147,6 +148,11 @@ export function snapshotState(): StateManifest {
     observability_impact: (r["observability_impact"] as string) ?? "",
     full_plan_md: (r["full_plan_md"] as string) ?? "",
     sequence: toNumeric(r["sequence"], 0) as number,
+    blocker_source: (r["blocker_source"] as string) ?? "",
+    escalation_pending: toNumeric(r["escalation_pending"], 0) as number,
+    escalation_awaiting_review: toNumeric(r["escalation_awaiting_review"], 0) as number,
+    escalation_artifact_path: (r["escalation_artifact_path"] as string) ?? null,
+    escalation_override_applied_at: (r["escalation_override_applied_at"] as string) ?? null,
   }));
 
   const rawDecisions = db.prepare("SELECT * FROM decisions ORDER BY seq").all() as Record<string, unknown>[];
@@ -160,6 +166,7 @@ export function snapshotState(): StateManifest {
     rationale: (r["rationale"] as string) ?? "",
     revisable: (r["revisable"] as string) ?? "",
     made_by: (r["made_by"] as string as Decision["made_by"]) ?? "agent",
+    source: (r["source"] as string) ?? "discussion",
     superseded_by: (r["superseded_by"] as string) ?? null,
   }));
 
@@ -186,109 +193,15 @@ export function snapshotState(): StateManifest {
     verification_evidence,
   };
 
-  db.exec("COMMIT");
   return result;
-  } catch (err) {
-    try { db.exec("ROLLBACK"); } catch { /* ignore rollback failure */ }
-    throw err;
-  }
+  });
 }
 
 // ─── restore ─────────────────────────────────────────────────────────────
-
-/**
- * Atomically replace all workflow state from a manifest.
- * Runs inside a transaction — if any insert fails, no tables are modified.
- * Only touches engine tables + decisions. Does NOT modify artifacts or memories.
- */
-function restore(manifest: StateManifest): void {
-  const db = requireDb();
-
-  transaction(() => {
-    // Clear engine tables (order matters for foreign-key-like consistency)
-    db.exec("DELETE FROM verification_evidence");
-    db.exec("DELETE FROM tasks");
-    db.exec("DELETE FROM slices");
-    db.exec("DELETE FROM milestones");
-    db.exec("DELETE FROM decisions WHERE 1=1");
-
-    // Restore milestones
-    const msStmt = db.prepare(
-      `INSERT INTO milestones (id, title, status, depends_on, created_at, completed_at,
-        vision, success_criteria, key_risks, proof_strategy,
-        verification_contract, verification_integration, verification_operational, verification_uat,
-        definition_of_done, requirement_coverage, boundary_map_markdown)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    );
-    for (const m of manifest.milestones) {
-      msStmt.run(
-        m.id, m.title, m.status,
-        JSON.stringify(m.depends_on), m.created_at, m.completed_at,
-        m.vision, JSON.stringify(m.success_criteria), JSON.stringify(m.key_risks),
-        JSON.stringify(m.proof_strategy),
-        m.verification_contract, m.verification_integration, m.verification_operational, m.verification_uat,
-        JSON.stringify(m.definition_of_done), m.requirement_coverage, m.boundary_map_markdown,
-      );
-    }
-
-    // Restore slices
-    const slStmt = db.prepare(
-      `INSERT INTO slices (milestone_id, id, title, status, risk, depends, demo,
-        created_at, completed_at, full_summary_md, full_uat_md,
-        goal, success_criteria, proof_level, integration_closure, observability_impact,
-        sequence, replan_triggered_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    );
-    for (const s of manifest.slices) {
-      slStmt.run(
-        s.milestone_id, s.id, s.title, s.status, s.risk,
-        JSON.stringify(s.depends), s.demo,
-        s.created_at, s.completed_at, s.full_summary_md, s.full_uat_md,
-        s.goal, s.success_criteria, s.proof_level, s.integration_closure, s.observability_impact,
-        s.sequence, s.replan_triggered_at,
-      );
-    }
-
-    // Restore tasks
-    const tkStmt = db.prepare(
-      `INSERT INTO tasks (milestone_id, slice_id, id, title, status,
-        one_liner, narrative, verification_result, duration, completed_at,
-        blocker_discovered, deviations, known_issues, key_files, key_decisions,
-        full_summary_md, description, estimate, files, verify,
-        inputs, expected_output, observability_impact, sequence)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    );
-    for (const t of manifest.tasks) {
-      tkStmt.run(
-        t.milestone_id, t.slice_id, t.id, t.title, t.status,
-        t.one_liner, t.narrative, t.verification_result, t.duration, t.completed_at,
-        t.blocker_discovered ? 1 : 0, t.deviations, t.known_issues,
-        JSON.stringify(t.key_files), JSON.stringify(t.key_decisions),
-        t.full_summary_md, t.description, t.estimate, JSON.stringify(t.files), t.verify,
-        JSON.stringify(t.inputs), JSON.stringify(t.expected_output),
-        t.observability_impact, t.sequence,
-      );
-    }
-
-    // Restore decisions
-    const dcStmt = db.prepare(
-      `INSERT INTO decisions (seq, id, when_context, scope, decision, choice, rationale, revisable, made_by, superseded_by)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    );
-    for (const d of manifest.decisions) {
-      dcStmt.run(d.seq, d.id, d.when_context, d.scope, d.decision, d.choice, d.rationale, d.revisable, d.made_by, d.superseded_by);
-    }
-
-    // Restore verification evidence
-    const evStmt = db.prepare(
-      `INSERT INTO verification_evidence (task_id, slice_id, milestone_id, command, exit_code, verdict, duration_ms, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
-    );
-    for (const e of manifest.verification_evidence) {
-      evStmt.run(e.task_id, e.slice_id, e.milestone_id, e.command, e.exit_code, e.verdict, e.duration_ms, e.created_at);
-    }
-  });
-}
+//
+// The actual restore() implementation lives in gsd-db.ts (single-writer
+// invariant). This module only orchestrates reading the manifest file
+// and handing it to the writer.
 
 // ─── writeManifest ───────────────────────────────────────────────────────
 
@@ -346,6 +259,6 @@ export function bootstrapFromManifest(basePath: string): boolean {
     return false;
   }
 
-  restore(manifest);
+  restoreManifest(manifest);
   return true;
 }

package/src/resources/extensions/gsd/workflow-mcp.ts

@@ -30,6 +30,7 @@ const MCP_WORKFLOW_TOOL_SURFACE = new Set([
   "gsd_journal_query",
   "gsd_milestone_complete",
   "gsd_milestone_generate_id",
+  "gsd_checkpoint_db",
   "gsd_milestone_status",
   "gsd_milestone_validate",
   "gsd_plan_task",
@@ -354,12 +355,6 @@ export function supportsStructuredQuestions(
 ): boolean {
   if (!activeTools.includes("ask_user_questions")) return false;
 
-  // Workflow MCP currently exposes ask_user_questions via MCP form elicitation.
-  // Local external CLI transports such as Claude Code can invoke the tool, but
-  // do not reliably complete that elicitation round-trip yet, so guided discuss
-  // prompts must fall back to plain-text questioning.
-  if (usesWorkflowMcpTransport(options.authMode, options.baseUrl)) return false;
-
   return true;
 }