gsd-pi 2.74.0 → 2.75.0-dev.fd2382b9f

package/dist/resources/extensions/gsd/commands-session-report.js

@@ -0,0 +1,82 @@
+/**
+ * GSD Command — /gsd session-report
+ *
+ * Summarizes the current session: tasks completed, cost, tokens,
+ * duration, model usage breakdown.
+ */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { getLedger, getProjectTotals, aggregateByModel, formatCost, formatTokenCount, loadLedgerFromDisk } from "./metrics.js";
+import { gsdRoot } from "./paths.js";
+import { formatDuration } from "../shared/format-utils.js";
+function formatSessionReport(units) {
+    const totals = getProjectTotals(units);
+    const byModel = aggregateByModel(units);
+    const lines = [];
+    lines.push("╭─ Session Report ──────────────────────────────────────╮");
+    if (totals.duration > 0) {
+        lines.push(`│ Duration:    ${formatDuration(totals.duration).padEnd(40)}│`);
+    }
+    lines.push(`│ Units:       ${String(units.length).padEnd(40)}│`);
+    lines.push(`│ Cost:        ${formatCost(totals.cost).padEnd(40)}│`);
+    lines.push(`│ Tokens:      ${`${formatTokenCount(totals.tokens.input)} in / ${formatTokenCount(totals.tokens.output)} out`.padEnd(40)}│`);
+    lines.push("│                                                       │");
+    // Work completed
+    if (units.length > 0) {
+        lines.push("│ Work Completed:                                       │");
+        for (const unit of units) {
+            const finished = unit.finishedAt > 0;
+            const status = finished ? "✓" : "•";
+            const label = `  ${status} ${unit.id ?? "unknown"}`;
+            lines.push(`│ ${label.padEnd(53)}│`);
+        }
+        lines.push("│                                                       │");
+    }
+    // Model usage
+    if (byModel.length > 0) {
+        lines.push("│ Model Usage:                                          │");
+        for (const m of byModel) {
+            const label = `  ${m.model}: ${m.units} units (${formatCost(m.cost)})`;
+            lines.push(`│ ${label.padEnd(53)}│`);
+        }
+    }
+    lines.push("╰───────────────────────────────────────────────────────╯");
+    return lines.join("\n");
+}
+export async function handleSessionReport(args, ctx) {
+    const basePath = process.cwd();
+    // Get units from in-memory ledger or disk
+    const ledger = getLedger();
+    let units;
+    if (ledger && ledger.units.length > 0) {
+        units = ledger.units;
+    }
+    else {
+        const diskLedger = loadLedgerFromDisk(basePath);
+        if (!diskLedger || diskLedger.units.length === 0) {
+            ctx.ui.notify("No session data — no units have been executed yet.", "info");
+            return;
+        }
+        units = diskLedger.units;
+    }
+    // JSON output
+    if (args.includes("--json")) {
+        const totals = getProjectTotals(units);
+        const byModel = aggregateByModel(units);
+        ctx.ui.notify(JSON.stringify({ units: units.length, totals, byModel }, null, 2), "info");
+        return;
+    }
+    // Save to file
+    if (args.includes("--save")) {
+        const report = formatSessionReport(units);
+        const reportsDir = join(gsdRoot(basePath), "reports");
+        mkdirSync(reportsDir, { recursive: true });
+        const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+        const outPath = join(reportsDir, `session-${timestamp}.md`);
+        writeFileSync(outPath, `\`\`\`\n${report}\n\`\`\`\n`, "utf-8");
+        ctx.ui.notify(`Report saved: ${outPath}`, "success");
+        return;
+    }
+    // Display
+    ctx.ui.notify(formatSessionReport(units), "info");
+}

package/dist/resources/extensions/gsd/commands-ship.js

@@ -0,0 +1,187 @@
+/**
+ * GSD Command — /gsd ship
+ *
+ * Creates a PR from milestone artifacts: generates title + body from
+ * roadmap, slice summaries, and metrics, then opens via `gh pr create`.
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { deriveState } from "./state.js";
+import { resolveMilestoneFile, resolveSlicePath, resolveSliceFile } from "./paths.js";
+import { getLedger, getProjectTotals, aggregateByModel, formatCost, formatTokenCount, loadLedgerFromDisk } from "./metrics.js";
+import { nativeGetCurrentBranch, nativeDetectMainBranch } from "./native-git-bridge.js";
+import { formatDuration } from "../shared/format-utils.js";
+function git(basePath, args) {
+    return execFileSync("git", args, { cwd: basePath, encoding: "utf-8" }).trim();
+}
+function isValidRefName(name) {
+    try {
+        execFileSync("git", ["check-ref-format", "--branch", name], { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function listSliceIds(basePath, milestoneId) {
+    // Slices live at <milestoneDir>/slices/<sliceId>/ with canonical S\d+ IDs.
+    // Use resolveSlicePath with a probe to find the real slices directory root.
+    const probe = resolveSlicePath(basePath, milestoneId, "S01");
+    let slicesDir = null;
+    if (probe) {
+        // probe looks like <milestoneDir>/slices/S01 — parent is slices dir.
+        slicesDir = probe.replace(/[\\/][^\\/]+$/, "");
+    }
+    else {
+        // Fall back to scanning the milestones roadmap file's sibling slices dir.
+        const roadmap = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
+        if (roadmap) {
+            slicesDir = roadmap.replace(/[\\/][^\\/]+$/, "") + "/slices";
+        }
+    }
+    if (!slicesDir || !existsSync(slicesDir))
+        return [];
+    try {
+        return readdirSync(slicesDir, { withFileTypes: true })
+            .filter((e) => e.isDirectory() && /^S\d+$/.test(e.name))
+            .map((e) => e.name)
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+function collectSliceSummaries(basePath, milestoneId) {
+    const summaries = [];
+    for (const sliceId of listSliceIds(basePath, milestoneId)) {
+        const summaryPath = resolveSliceFile(basePath, milestoneId, sliceId, "SUMMARY");
+        if (!summaryPath || !existsSync(summaryPath))
+            continue;
+        try {
+            const content = readFileSync(summaryPath, "utf-8").trim();
+            if (content)
+                summaries.push(`### ${sliceId}\n${content}`);
+        }
+        catch {
+            // non-fatal
+        }
+    }
+    return summaries;
+}
+function generatePRContent(basePath, milestoneId, milestoneTitle) {
+    const title = `feat: ${milestoneTitle || milestoneId}`;
+    const sections = [];
+    // TL;DR
+    sections.push("## TL;DR\n");
+    sections.push(`**What:** Ship milestone ${milestoneId} — ${milestoneTitle || "(untitled)"}`);
+    sections.push(`**Why:** Milestone work complete, ready for review.`);
+    sections.push(`**How:** See slice summaries below.\n`);
+    // What — slice summaries
+    const summaries = collectSliceSummaries(basePath, milestoneId);
+    if (summaries.length > 0) {
+        sections.push("## What\n");
+        sections.push(summaries.join("\n\n"));
+        sections.push("");
+    }
+    // Roadmap status
+    const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
+    if (roadmapPath && existsSync(roadmapPath)) {
+        try {
+            const roadmap = readFileSync(roadmapPath, "utf-8");
+            const checkboxLines = roadmap.split("\n").filter((l) => /^\s*-\s*\[[ x]\]/.test(l));
+            if (checkboxLines.length > 0) {
+                sections.push("## Roadmap\n");
+                sections.push(checkboxLines.join("\n"));
+                sections.push("");
+            }
+        }
+        catch {
+            // non-fatal
+        }
+    }
+    // Metrics
+    const ledger = getLedger();
+    const units = ledger?.units ?? loadLedgerFromDisk(basePath)?.units ?? [];
+    if (units.length > 0) {
+        const totals = getProjectTotals(units);
+        const byModel = aggregateByModel(units);
+        sections.push("## Metrics\n");
+        sections.push(`- **Units executed:** ${units.length}`);
+        sections.push(`- **Total cost:** ${formatCost(totals.cost)}`);
+        sections.push(`- **Tokens:** ${formatTokenCount(totals.tokens.input)} input / ${formatTokenCount(totals.tokens.output)} output`);
+        if (totals.duration > 0) {
+            sections.push(`- **Duration:** ${formatDuration(totals.duration)}`);
+        }
+        if (byModel.length > 0) {
+            sections.push(`- **Models:** ${byModel.map((m) => `${m.model} (${m.units} units)`).join(", ")}`);
+        }
+        sections.push("");
+    }
+    // Change type checklist
+    sections.push("## Change type\n");
+    sections.push("- [x] `feat` — New feature or capability");
+    sections.push("- [ ] `fix` — Bug fix");
+    sections.push("- [ ] `refactor` — Code restructuring");
+    sections.push("- [ ] `test` — Adding or updating tests");
+    sections.push("- [ ] `docs` — Documentation only");
+    sections.push("- [ ] `chore` — Build, CI, or tooling changes\n");
+    // AI disclosure
+    sections.push("---\n");
+    sections.push("*This PR was prepared with AI assistance (GSD auto-mode).*");
+    return { title, body: sections.join("\n") };
+}
+export async function handleShip(args, ctx, _pi) {
+    const basePath = process.cwd();
+    const dryRun = args.includes("--dry-run");
+    const draft = args.includes("--draft");
+    const force = args.includes("--force");
+    const baseMatch = args.match(/--base\s+(\S+)/);
+    const base = baseMatch?.[1] ?? nativeDetectMainBranch(basePath);
+    if (!isValidRefName(base)) {
+        ctx.ui.notify(`Invalid base branch name: ${base}`, "error");
+        return;
+    }
+    // 1. Validate milestone state
+    const state = await deriveState(basePath);
+    if (!state.activeMilestone) {
+        ctx.ui.notify("No active milestone to ship. Complete milestone work first.", "warning");
+        return;
+    }
+    const milestoneId = state.activeMilestone.id;
+    const milestoneTitle = state.activeMilestone.title ?? "";
+    // 2. Check for incomplete work (use GSD phase as proxy — no phase field on ActiveRef)
+    if (state.phase !== "complete" && !force) {
+        ctx.ui.notify(`Milestone ${milestoneId} may not be complete (phase: ${state.phase}). Use --force to ship anyway.`, "warning");
+        return;
+    }
+    // 3. Generate PR content
+    const { title, body } = generatePRContent(basePath, milestoneId, milestoneTitle);
+    // 4. Dry-run — just show the PR content
+    if (dryRun) {
+        ctx.ui.notify(`--- PR Preview ---\n\nTitle: ${title}\n\n${body}`, "info");
+        return;
+    }
+    // 5. Check git state
+    const currentBranch = nativeGetCurrentBranch(basePath);
+    if (!isValidRefName(currentBranch)) {
+        ctx.ui.notify(`Current branch name is invalid for git: ${currentBranch}`, "error");
+        return;
+    }
+    if (currentBranch === base) {
+        ctx.ui.notify(`You're on ${base} — create a feature branch first.`, "warning");
+        return;
+    }
+    // 6. Push and create PR (all argv-safe, no shell interpolation)
+    try {
+        git(basePath, ["push", "-u", "origin", currentBranch]);
+        const ghArgs = ["pr", "create", "--base", base, "--title", title, "--body", body];
+        if (draft)
+            ghArgs.push("--draft");
+        const prUrl = execFileSync("gh", ghArgs, { cwd: basePath, encoding: "utf-8" }).trim();
+        ctx.ui.notify(`PR created: ${prUrl}`, "success");
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        ctx.ui.notify(`Failed to create PR: ${msg}`, "error");
+    }
+}

package/dist/resources/extensions/gsd/commands-workflow-templates.js

@@ -12,6 +12,7 @@ import { gsdRoot } from "./paths.js";
 import { createGitService, runGit } from "./git-service.js";
 import { isAutoActive, isAutoPaused } from "./auto.js";
 import { getErrorMessage } from "./error-utils.js";
+import { resolvePlugin } from "./workflow-plugins.js";
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 /**
  * Generate a URL-friendly slug from text.
@@ -257,8 +258,19 @@ export async function handleStart(args, ctx, pi) {
     const template = match.template;
     const basePath = process.cwd();
     const date = new Date().toISOString().split("T")[0];
-    // Load the workflow template content
-    const workflowContent = loadWorkflowTemplate(templateId);
+    // Load the workflow template content — prefer a project/global plugin
+    // override if one exists (same name, .md format).
+    let workflowContent = null;
+    const pluginOverride = resolvePlugin(basePath, templateId);
+    if (pluginOverride && pluginOverride.source !== "bundled" && pluginOverride.format === "md") {
+        try {
+            workflowContent = readFileSync(pluginOverride.path, "utf-8");
+        }
+        catch { /* fall through to bundled */ }
+    }
+    if (workflowContent == null) {
+        workflowContent = loadWorkflowTemplate(templateId);
+    }
     if (!workflowContent) {
         ctx.ui.notify(`Template "${templateId}" is registered but its workflow file (${template.file}) hasn't been created yet.`, "warning");
         return;
@@ -406,3 +418,90 @@ export function getTemplateCompletions(prefix) {
         return [];
     }
 }
+// ─── Shared markdown-phase dispatcher (used by /gsd workflow <name>) ────────
+/**
+ * Dispatch a markdown-phase workflow plugin. Mirrors `handleStart`'s execution
+ * branch for resolved templates, but accepts a pre-resolved plugin (from the
+ * unified plugin resolver).
+ *
+ * Writes STATE.json into an artifact dir, creates a git branch, and dispatches
+ * the `workflow-start` prompt.
+ */
+export function dispatchMarkdownPhasePlugin(plugin, description, ctx, pi) {
+    if (plugin.meta.mode !== "markdown-phase")
+        return;
+    if (isAutoActive()) {
+        ctx.ui.notify("Cannot start a markdown-phase workflow while auto-mode is running.\n" +
+            "Run /gsd pause first.", "warning");
+        return;
+    }
+    const templateId = plugin.name;
+    const basePath = process.cwd();
+    const date = new Date().toISOString().split("T")[0];
+    let workflowContent;
+    try {
+        workflowContent = readFileSync(plugin.path, "utf-8");
+    }
+    catch (err) {
+        ctx.ui.notify(`Failed to read template: ${err instanceof Error ? err.message : String(err)}`, "error");
+        return;
+    }
+    // Create artifact directory.
+    let artifactDir = "";
+    if (plugin.meta.artifactDir) {
+        const slug = slugify(description || templateId);
+        const prefix = datePrefix();
+        const num = getNextWorkflowNum(join(basePath, plugin.meta.artifactDir));
+        artifactDir = `${plugin.meta.artifactDir}${prefix}-${num}-${slug}`;
+        mkdirSync(join(basePath, artifactDir), { recursive: true });
+    }
+    // Create git branch unless isolation: none.
+    const git = createGitService(basePath);
+    const skipBranch = git.prefs.isolation === "none";
+    const slug = slugify(description || templateId);
+    const branchName = `gsd/${templateId}/${slug}`;
+    let branchCreated = false;
+    if (!skipBranch) {
+        try {
+            const current = git.getCurrentBranch();
+            if (current !== branchName) {
+                try {
+                    git.autoCommit("workflow-template", templateId, []);
+                }
+                catch { /* nothing to commit */ }
+                runGit(basePath, ["checkout", "-b", branchName]);
+                branchCreated = true;
+            }
+        }
+        catch (err) {
+            ctx.ui.notify(`Could not create branch ${branchName}: ${getErrorMessage(err)}. Working on current branch.`, "warning");
+        }
+    }
+    const actualBranch = branchCreated ? branchName : git.getCurrentBranch();
+    // Write STATE.json.
+    if (artifactDir && plugin.meta.phases && plugin.meta.phases.length > 0) {
+        writeWorkflowState(join(basePath, artifactDir), templateId, plugin.meta.displayName, plugin.meta.phases, description, actualBranch);
+    }
+    const infoLines = [
+        `Starting workflow: ${plugin.meta.displayName}`,
+        `Phases: ${(plugin.meta.phases ?? []).join(" → ")}`,
+    ];
+    if (artifactDir)
+        infoLines.push(`Artifacts: ${artifactDir}`);
+    infoLines.push(`Branch: ${actualBranch}`);
+    ctx.ui.notify(infoLines.join("\n"), "info");
+    const prompt = loadPrompt("workflow-start", {
+        templateId,
+        templateName: plugin.meta.displayName,
+        templateDescription: plugin.meta.description ?? "",
+        phases: (plugin.meta.phases ?? []).join(" → "),
+        complexity: plugin.meta.complexity ?? "medium",
+        artifactDir: artifactDir || "(none)",
+        branch: actualBranch,
+        description: description || "(none provided)",
+        issueRef: "(none)",
+        date,
+        workflowContent,
+    });
+    pi.sendMessage({ customType: "gsd-workflow-template", content: prompt, display: false }, { triggerTurn: true });
+}

package/dist/resources/extensions/gsd/custom-workflow-engine.js

@@ -13,7 +13,7 @@
  */
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import { readGraph, writeGraph, getNextPendingStep, markStepComplete, expandIteration, } from "./graph.js";
+import { readGraph, writeGraph, getNextPendingStep, markStepActive, markStepComplete, expandIteration, } from "./graph.js";
 import { injectContext } from "./context-injector.js";
 import { readFrozenDefinition } from "./definition-io.js";
 import { parseUnitId } from "./unit-id.js";
@@ -62,66 +62,86 @@ export class CustomWorkflowEngine {
      * - Expanded GRAPH.yaml is written to disk before dispatch — inspectable on disk.
      */
     async resolveDispatch(state, _context) {
-        let graph = state.raw;
-        let next = getNextPendingStep(graph);
-        if (!next) {
-            return {
-                action: "stop",
-                reason: "All steps complete",
-                level: "info",
-            };
-        }
-        // Check frozen DEFINITION.yaml for iterate config on this step
-        const def = readFrozenDefinition(this.runDir);
-        const stepDef = def.steps.find((s) => s.id === next.id);
-        if (stepDef?.iterate) {
-            const iterate = stepDef.iterate;
-            // Read source artifact
-            const sourcePath = join(this.runDir, iterate.source);
-            let sourceContent;
-            try {
-                sourceContent = readFileSync(sourcePath, "utf-8");
-            }
-            catch {
-                throw new Error(`Iterate source artifact not found: ${sourcePath} (step "${next.id}", source: "${iterate.source}")`);
-            }
-            // Extract items via regex with global+multiline flags.
-            // Guard against ReDoS: if matching takes too long on large inputs, bail.
-            const regex = new RegExp(iterate.pattern, "gm");
-            const items = [];
-            const matchStart = Date.now();
-            let match;
-            while ((match = regex.exec(sourceContent)) !== null) {
-                if (match[1] !== undefined)
-                    items.push(match[1]);
-                if (Date.now() - matchStart > 5_000) {
-                    throw new Error(`Iterate pattern "${iterate.pattern}" exceeded 5s timeout on step "${next.id}" — possible ReDoS`);
-                }
+        const graphPath = join(this.runDir, "GRAPH.yaml");
+        return await withFileLock(graphPath, () => {
+            let graph = readGraph(this.runDir);
+            const active = graph.steps.find((step) => step.status === "active");
+            if (active) {
+                return {
+                    action: "dispatch",
+                    step: {
+                        unitType: "custom-step",
+                        unitId: `${graph.metadata.name}/${active.id}`,
+                        prompt: injectContext(this.runDir, active.id, active.prompt),
+                    },
+                };
             }
-            // Expand the graph
-            const expandedGraph = expandIteration(graph, next.id, items, next.prompt);
-            writeGraph(this.runDir, expandedGraph);
-            graph = expandedGraph;
-            // Re-query for first instance step
-            next = getNextPendingStep(expandedGraph);
+            let next = getNextPendingStep(graph);
             if (!next) {
                 return {
                     action: "stop",
-                    reason: "Iterate expansion produced no instances",
+                    reason: "All steps complete",
                     level: "info",
                 };
             }
-        }
-        // Enrich prompt with context from prior step artifacts
-        const enrichedPrompt = injectContext(this.runDir, next.id, next.prompt);
-        return {
-            action: "dispatch",
-            step: {
-                unitType: "custom-step",
-                unitId: `${graph.metadata.name}/${next.id}`,
-                prompt: enrichedPrompt,
-            },
-        };
+            // Check frozen DEFINITION.yaml for iterate config on this step
+            const def = readFrozenDefinition(this.runDir);
+            const stepDef = def.steps.find((s) => s.id === next.id);
+            if (stepDef?.iterate) {
+                const iterate = stepDef.iterate;
+                // Read source artifact
+                const sourcePath = join(this.runDir, iterate.source);
+                let sourceContent;
+                try {
+                    sourceContent = readFileSync(sourcePath, "utf-8");
+                }
+                catch {
+                    throw new Error(`Iterate source artifact not found: ${sourcePath} (step "${next.id}", source: "${iterate.source}")`);
+                }
+                // Extract items via regex with global+multiline flags.
+                // Guard against ReDoS: if matching takes too long on large inputs, bail.
+                const regex = new RegExp(iterate.pattern, "gm");
+                const items = [];
+                const matchStart = Date.now();
+                let match;
+                while ((match = regex.exec(sourceContent)) !== null) {
+                    if (match[1] !== undefined)
+                        items.push(match[1]);
+                    if (Date.now() - matchStart > 5_000) {
+                        throw new Error(`Iterate pattern "${iterate.pattern}" exceeded 5s timeout on step "${next.id}" — possible ReDoS`);
+                    }
+                }
+                // Expand the graph
+                const expandedGraph = expandIteration(graph, next.id, items, next.prompt);
+                writeGraph(this.runDir, expandedGraph);
+                graph = expandedGraph;
+                // Re-query for first instance step
+                next = getNextPendingStep(expandedGraph);
+                if (!next) {
+                    return {
+                        action: "stop",
+                        reason: "Iterate expansion produced no instances",
+                        level: "info",
+                    };
+                }
+            }
+            const activeGraph = markStepActive(graph, next.id);
+            writeGraph(this.runDir, activeGraph);
+            const activeStep = activeGraph.steps.find((s) => s.id === next.id);
+            if (!activeStep) {
+                throw new Error(`Active step not found after GRAPH.yaml update: ${next.id}`);
+            }
+            // Enrich prompt with context from prior step artifacts
+            const enrichedPrompt = injectContext(this.runDir, activeStep.id, activeStep.prompt);
+            return {
+                action: "dispatch",
+                step: {
+                    unitType: "custom-step",
+                    unitId: `${activeGraph.metadata.name}/${activeStep.id}`,
+                    prompt: enrichedPrompt,
+                },
+            };
+        });
     }
     /**
      * Reconcile state after a step completes.

package/dist/resources/extensions/gsd/db-writer.js

@@ -301,8 +301,7 @@ export async function saveRequirementToDb(fields, basePath) {
         catch (diskErr) {
             logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveRequirementToDb', error: String(diskErr.message) });
             try {
-                const rollbackAdapter = db._getAdapter();
-                rollbackAdapter?.prepare('DELETE FROM requirements WHERE id = :id').run({ ':id': id });
+                db.deleteRequirementById(id);
             }
             catch (rollbackErr) {
                 logError('manifest', 'SPLIT BRAIN: disk write failed AND DB rollback failed — DB has orphaned row', { fn: 'saveRequirementToDb', id, error: String(rollbackErr.message) });
@@ -354,6 +353,7 @@ export async function saveDecisionToDb(fields, basePath) {
                 rationale: fields.rationale,
                 revisable: fields.revisable ?? 'Yes',
                 made_by: fields.made_by ?? 'agent',
+                source: fields.source ?? 'discussion',
                 superseded_by: null,
             });
             return nextId;
@@ -405,7 +405,7 @@ export async function saveDecisionToDb(fields, basePath) {
         catch (diskErr) {
             logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveDecisionToDb', error: String(diskErr.message) });
             try {
-                adapter?.prepare('DELETE FROM decisions WHERE id = :id').run({ ':id': id });
+                db.deleteDecisionById(id);
             }
             catch (rollbackErr) {
                 logError('manifest', 'SPLIT BRAIN: disk write failed AND DB rollback failed — DB has orphaned row', { fn: 'saveDecisionToDb', id, error: String(rollbackErr.message) });
@@ -614,8 +614,7 @@ export async function saveArtifactToDb(opts, basePath) {
             }
             catch (diskErr) {
                 logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveArtifactToDb', error: String(diskErr.message) });
-                const rollbackAdapter = db._getAdapter();
-                rollbackAdapter?.prepare('DELETE FROM artifacts WHERE path = :path').run({ ':path': opts.path });
+                db.deleteArtifactByPath(opts.path);
                 throw diskErr;
             }
         }