gsd-pi 2.74.0 → 2.75.0-dev.fd2382b9f

package/dist/resources/extensions/gsd/workflow-install.js

@@ -0,0 +1,327 @@
+/**
+ * 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";
+function provenancePath(dir) {
+    return join(dir, PROVENANCE_FILE);
+}
+function readProvenance(dir) {
+    const path = provenancePath(dir);
+    if (!existsSync(path))
+        return {};
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeProvenance(dir, data) {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(provenancePath(dir), JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+export function globalInstallDir() {
+    const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
+    return join(gsdHome, "workflows");
+}
+export function projectInstallDir(basePath) {
+    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) {
+    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, child) {
+    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) {
+    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]`);
+}
+/**
+ * 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) {
+    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;
+        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;
+        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;
+                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) {
+    if (fetched.ext === ".yaml" || fetched.ext === ".yml") {
+        let parsed;
+        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.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) {
+    if (fetched.ext === ".yaml" || fetched.ext === ".yml") {
+        try {
+            const parsed = parseYaml(fetched.content);
+            if (parsed && typeof parsed === "object") {
+                const n = parsed.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) {
+    return raw.trim().toLowerCase().replace(/[^a-z0-9._-]/g, "-").replace(/^-+|-+$/g, "");
+}
+/**
+ * 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, fetched, name) {
+    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 };
+}
+/**
+ * Remove an installed plugin and its provenance record.
+ * Checks global dir first, then project (same order as install default).
+ */
+export function uninstallPlugin(basePath, name) {
+    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, maxLines = 20) {
+    const lines = content.split(/\r?\n/).slice(0, maxLines);
+    return lines.join("\n");
+}

package/dist/resources/extensions/gsd/workflow-logger.js

@@ -18,6 +18,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";
 // ─── Buffer & Persistent Audit ──────────────────────────────────────────
 const MAX_BUFFER = 100;
 let _buffer = [];
@@ -202,6 +204,26 @@ function _push(severity, component, message, context) {
     if (_buffer.length > MAX_BUFFER) {
         _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.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/dist/resources/extensions/gsd/workflow-manifest.js

@@ -1,4 +1,4 @@
-import { _getAdapter, transaction, } from "./gsd-db.js";
+import { _getAdapter, readTransaction, restoreManifest, } from "./gsd-db.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { readFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
@@ -41,8 +41,7 @@ export function snapshotState() {
     const db = requireDb();
     // 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();
         const milestones = rawMilestones.map((r) => ({
             id: r["id"],
@@ -83,6 +82,8 @@ export function snapshotState() {
             observability_impact: r["observability_impact"] ?? "",
             sequence: toNumeric(r["sequence"], 0),
             replan_triggered_at: r["replan_triggered_at"] ?? null,
+            is_sketch: toNumeric(r["is_sketch"], 0),
+            sketch_scope: r["sketch_scope"] ?? "",
         }));
         const rawTasks = db.prepare("SELECT * FROM tasks ORDER BY milestone_id, slice_id, sequence, id").all();
         const tasks = rawTasks.map((r) => ({
@@ -111,6 +112,11 @@ export function snapshotState() {
             observability_impact: r["observability_impact"] ?? "",
             full_plan_md: r["full_plan_md"] ?? "",
             sequence: toNumeric(r["sequence"], 0),
+            blocker_source: r["blocker_source"] ?? "",
+            escalation_pending: toNumeric(r["escalation_pending"], 0),
+            escalation_awaiting_review: toNumeric(r["escalation_awaiting_review"], 0),
+            escalation_artifact_path: r["escalation_artifact_path"] ?? null,
+            escalation_override_applied_at: r["escalation_override_applied_at"] ?? null,
         }));
         const rawDecisions = db.prepare("SELECT * FROM decisions ORDER BY seq").all();
         const decisions = rawDecisions.map((r) => ({
@@ -123,6 +129,7 @@ export function snapshotState() {
             rationale: r["rationale"] ?? "",
             revisable: r["revisable"] ?? "",
             made_by: r["made_by"] ?? "agent",
+            source: r["source"] ?? "discussion",
             superseded_by: r["superseded_by"] ?? null,
         }));
         const rawEvidence = db.prepare("SELECT * FROM verification_evidence ORDER BY id").all();
@@ -146,74 +153,14 @@ export function snapshotState() {
             decisions,
             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) {
-    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);
-        }
     });
 }
+// ─── restore ─────────────────────────────────────────────────────────────
+//
+// 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 ───────────────────────────────────────────────────────
 /**
  * Write current DB state to .gsd/state-manifest.json via atomicWriteSync.
@@ -258,6 +205,6 @@ export function bootstrapFromManifest(basePath) {
     if (!manifest) {
         return false;
     }
-    restore(manifest);
+    restoreManifest(manifest);
     return true;
 }

package/dist/resources/extensions/gsd/workflow-mcp.js

@@ -12,6 +12,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",
@@ -290,12 +291,6 @@ export function usesWorkflowMcpTransport(authMode, baseUrl) {
 export function supportsStructuredQuestions(activeTools, options = {}) {
     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;
 }
 export function getWorkflowTransportSupportError(provider, requiredTools, options = {}) {

package/dist/resources/extensions/gsd/workflow-migration.js

@@ -4,7 +4,7 @@
 // Populates data into the already-existing v10 schema tables.
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { _getAdapter, transaction } from "./gsd-db.js";
+import { _getAdapter, bulkInsertLegacyHierarchy } from "./gsd-db.js";
 import { parseRoadmap, parsePlan } from "./parsers-legacy.js";
 import { logWarning } from "./workflow-logger.js";
 // ─── needsAutoMigration ───────────────────────────────────────────────────
@@ -174,27 +174,26 @@ export function migrateFromMarkdown(basePath) {
         process.stderr.write("workflow-migration: no milestones collected, nothing to insert\n");
         return;
     }
-    const placeholders = migratedMilestoneIds.map(() => "?").join(",");
-    transaction(() => {
-        // Clear existing data to handle stale DB shape (DELETE ... IN (...))
-        db.prepare(`DELETE FROM tasks WHERE milestone_id IN (${placeholders})`).run(...migratedMilestoneIds);
-        db.prepare(`DELETE FROM slices WHERE milestone_id IN (${placeholders})`).run(...migratedMilestoneIds);
-        db.prepare(`DELETE FROM milestones WHERE id IN (${placeholders})`).run(...migratedMilestoneIds);
-        // Insert milestones
-        const insertMilestone = db.prepare("INSERT INTO milestones (id, title, status, created_at) VALUES (?, ?, ?, ?)");
-        for (const m of milestoneInserts) {
-            insertMilestone.run(m.id, m.title, m.status, now);
-        }
-        // Insert slices (using v10 column names: depends, sequence)
-        const insertSlice = db.prepare("INSERT INTO slices (id, milestone_id, title, status, risk, depends, sequence, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
-        for (const s of sliceInserts) {
-            insertSlice.run(s.id, s.milestoneId, s.title, s.status, s.risk, "[]", s.sequence, now);
-        }
-        // Insert tasks (using v10 column names: sequence, blocker_discovered, full_summary_md)
-        const insertTask = db.prepare("INSERT INTO tasks (id, slice_id, milestone_id, title, description, status, estimate, files, sequence) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)");
-        for (const t of taskInserts) {
-            insertTask.run(t.id, t.sliceId, t.milestoneId, t.title, "", t.status, "", "[]", t.sequence);
-        }
+    bulkInsertLegacyHierarchy({
+        milestones: milestoneInserts,
+        slices: sliceInserts.map(s => ({
+            id: s.id,
+            milestoneId: s.milestoneId,
+            title: s.title,
+            status: s.status,
+            risk: s.risk,
+            sequence: s.sequence,
+        })),
+        tasks: taskInserts.map(t => ({
+            id: t.id,
+            sliceId: t.sliceId,
+            milestoneId: t.milestoneId,
+            title: t.title,
+            status: t.status,
+            sequence: t.sequence,
+        })),
+        clearMilestoneIds: migratedMilestoneIds,
+        createdAt: now,
     });
 }
 // ─── validateMigration ────────────────────────────────────────────────────