@ghostwater/soulforge 0.6.0 → 0.8.0

package/dist/cli/cli.js

@@ -2,16 +2,16 @@
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
-import { execSync } from "node:child_process";
-import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import { createRun, getRun, listRuns, getStepsForRun, getStoriesForRun, getEvents, updateStepStatus, updateRunStatus, advancePipeline, insertEvent, resetToStep, getDb, } from "../db/database.js";
+import { createRun, getRun, listRuns, getStepsForRun, getLoopItemsForRun, getEvents, updateStepStatus, updateRunStatus, updateRunContext, advancePipeline, insertEvent, resetToStep, getDb, getDataDir, } from "../db/database.js";
 import { loadWorkflowSpec } from "../workflow/parser.js";
+import { validateOutput } from "../workflow/schema-validator.js";
+import { getContextValue, parseGateLoopCounts, resolveGateRoute } from "../workflow/gate-routing.js";
+import { findBuiltinWorkflowByName, findNamedWorkflow, getCustomWorkflowPath, getCustomWorkflowRoot, listDiscoveredWorkflows, resolveWorkflowInput, } from "../workflow/discovery.js";
 import { listExecutors } from "../executors/registry.js";
 import { isDaemonRunning, startDaemonBackground, stopDaemon } from "../daemon/daemon.js";
 import { readRecentLogs } from "../lib/logger.js";
-import { createWorktree, validateGitRepo } from "../lib/worktree.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 function getVersion() {
@@ -35,20 +35,28 @@ Usage:
   soulforge run <workflow> "<task>" [options]
                                Start a workflow run
     --var key=value            Set workflow variable
-    --workdir <path>           Work in an existing directory (no git ops)
-    --no-worktree              Work directly in the repo without creating a worktree
-    --branch <name>            Branch name for worktree (default: soulforge/<id>)
-    --callback-url <url>       Callback URL for step notifications (required)
+    --workdir <path>           Work in an existing directory (required)
+    --keep-worktree            Keep worktree metadata/files after run completion
+    --callback-url <url>       Callback URL for step notifications
+    --callback-exec <command>  Shell command callback for step notifications
     --callback-headers <json>  Headers for callback requests
     --callback-body <json>     Body template for callback requests
-    --no-callback              Run without callbacks (explicit opt-out)
+    --no-callback              Run without callbacks (disables URL + exec callbacks)
     --executor <name>          Override executor for all code steps (e.g., codex-cli)
+    --model <name>             Override model for all code steps (e.g., gpt-4o)
+  soulforge workflow list      List built-in and custom workflows
+  soulforge workflow show <name>
+                               Show workflow YAML by name
+  soulforge workflow create <name> [--from <template>] [--force]
+                               Create custom workflow in ~/.soulforge/workflows
   soulforge status [<query>]   Check run status (ID prefix or task substring)
   soulforge runs               List all runs
   soulforge approve <run-id> [--message "..."]
                                Approve a checkpoint
   soulforge reject <run-id> --reason "..."
                                Reject a checkpoint
+  soulforge complete --run-id <id> --step-id <id> --data '<json>'
+                               Complete a step and persist output data
   soulforge cancel <run-id>    Cancel a running workflow
   soulforge resume <run-id>    Resume a failed run
 
@@ -61,6 +69,46 @@ Usage:
 Environment:
   SOULFORGE_DATA_DIR          Data directory (default: ~/.soulforge)`);
 }
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function formatDaemonStatusLine() {
+    const status = isDaemonRunning();
+    if (!status.running || !status.pid) {
+        return "Daemon: not running";
+    }
+    const heartbeatPath = path.join(getDataDir(), "heartbeat");
+    try {
+        const heartbeatRaw = readFileSync(heartbeatPath, "utf-8").trim();
+        const heartbeat = Number.parseInt(heartbeatRaw, 10);
+        if (!Number.isFinite(heartbeat)) {
+            throw new Error("Heartbeat is not numeric");
+        }
+        const ageMs = Math.max(0, Date.now() - heartbeat);
+        if (ageMs < 30_000) {
+            const ageSeconds = Math.floor(ageMs / 1000);
+            return `Daemon: running (PID ${status.pid}, last tick ${ageSeconds}s ago)`;
+        }
+        const ageMinutes = Math.max(1, Math.floor(ageMs / 60_000));
+        return `Daemon: ⚠️  running (PID ${status.pid}, last tick ${ageMinutes}m ago — may be hung)`;
+    }
+    catch {
+        return `Daemon: ⚠️  running (PID ${status.pid}, last tick unknown — may be hung)`;
+    }
+}
+function isValidWorkflowName(name) {
+    return /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name);
+}
+function buildDefaultWorkflowTemplate(name) {
+    return `id: ${name}
+name: ${name}
+steps:
+  - id: implement
+    executor: codex
+    input: |
+      Implement the requested task.
+`;
+}
 async function main() {
     const args = process.argv.slice(2);
     const [group, action, ...rest] = args;
@@ -93,16 +141,83 @@ async function main() {
             return;
         }
         if (action === "status") {
-            const status = isDaemonRunning();
-            if (status.running) {
-                console.log(`Daemon running (PID ${status.pid})`);
+            console.log(formatDaemonStatusLine());
+            return;
+        }
+        printUsage();
+        process.exit(1);
+    }
+    // ── Workflow commands ───────────────────────────────────────────
+    if (group === "workflow") {
+        if (action === "list") {
+            const workflows = await listDiscoveredWorkflows();
+            if (workflows.length === 0) {
+                console.log("No workflows found.");
+                return;
+            }
+            for (const workflow of workflows) {
+                console.log(`${workflow.name}\t${workflow.source}`);
+            }
+            return;
+        }
+        if (action === "show") {
+            const name = rest[0];
+            if (!name) {
+                console.error("Missing workflow name. Usage: soulforge workflow show <name>");
+                process.exit(1);
+            }
+            const workflow = await findNamedWorkflow(name);
+            if (!workflow) {
+                console.error(`Workflow not found by name: ${name}`);
+                process.exit(1);
+            }
+            console.log(readFileSync(workflow.path, "utf-8"));
+            return;
+        }
+        if (action === "create") {
+            const name = rest[0];
+            if (!name) {
+                console.error("Missing workflow name. Usage: soulforge workflow create <name> [--from <template>] [--force]");
+                process.exit(1);
+            }
+            if (!isValidWorkflowName(name)) {
+                console.error(`Invalid workflow name "${name}". Use letters, numbers, dot, underscore, and hyphen only.`);
+                process.exit(1);
+            }
+            let fromTemplate;
+            let force = false;
+            for (let i = 1; i < rest.length; i += 1) {
+                if (rest[i] === "--from" && rest[i + 1]) {
+                    fromTemplate = rest[i + 1];
+                    i += 1;
+                }
+                else if (rest[i] === "--force") {
+                    force = true;
+                }
+            }
+            const destinationPath = getCustomWorkflowPath(name);
+            if (fs.existsSync(destinationPath) && !force) {
+                console.error(`Workflow already exists: ${destinationPath}. Use --force to overwrite.`);
+                process.exit(1);
+            }
+            let templateContent;
+            if (fromTemplate) {
+                const sourceWorkflow = await findBuiltinWorkflowByName(fromTemplate);
+                if (!sourceWorkflow) {
+                    console.error(`Built-in workflow not found: ${fromTemplate}`);
+                    process.exit(1);
+                }
+                templateContent = readFileSync(sourceWorkflow.path, "utf-8");
             }
             else {
-                console.log("Daemon is not running.");
+                templateContent = buildDefaultWorkflowTemplate(name);
             }
+            fs.mkdirSync(getCustomWorkflowRoot(), { recursive: true });
+            fs.writeFileSync(destinationPath, templateContent);
+            console.log(`Created workflow: ${destinationPath}`);
             return;
         }
-        printUsage();
+        console.error("Unknown workflow command. Use: list, show, create");
         process.exit(1);
     }
     // ── Run command ─────────────────────────────────────────────────
@@ -119,13 +234,15 @@ async function main() {
         // Parse flags (order-independent)
         const vars = {};
         let workdir;
-        let noWorktree = false;
-        let branchName;
         let callbackUrl;
+        let callbackExec;
         let callbackHeaders;
         let callbackBodyTemplate;
         let noCallback = false;
+        let keepWorktree = false;
         let executorOverride;
+        let modelOverride;
+        let modelFlagSeen = false;
         for (let i = 1; i < rest.length; i++) {
             if (rest[i] === "--var" && rest[i + 1]) {
                 const [key, ...valParts] = rest[i + 1].split("=");
@@ -136,17 +253,14 @@ async function main() {
                 workdir = rest[i + 1];
                 i++;
             }
-            else if (rest[i] === "--no-worktree") {
-                noWorktree = true;
-            }
-            else if (rest[i] === "--branch" && rest[i + 1]) {
-                branchName = rest[i + 1];
-                i++;
-            }
             else if (rest[i] === "--callback-url" && rest[i + 1]) {
                 callbackUrl = rest[i + 1];
                 i++;
             }
+            else if (rest[i] === "--callback-exec" && rest[i + 1]) {
+                callbackExec = rest[i + 1];
+                i++;
+            }
             else if (rest[i] === "--callback-headers" && rest[i + 1]) {
                 try {
                     callbackHeaders = JSON.parse(rest[i + 1]);
@@ -170,36 +284,51 @@ async function main() {
             else if (rest[i] === "--no-callback") {
                 noCallback = true;
             }
+            else if (rest[i] === "--keep-worktree") {
+                keepWorktree = true;
+            }
             else if (rest[i] === "--executor" && rest[i + 1]) {
                 executorOverride = rest[i + 1];
                 i++;
             }
+            else if (rest[i] === "--model") {
+                modelFlagSeen = true;
+                modelOverride = rest[i + 1];
+                if (rest[i + 1] !== undefined) {
+                    i++;
+                }
+            }
+        }
+        if (!workdir) {
+            if (vars.repo) {
+                console.error("Error: --workdir is required. Specify the project directory for this run. (Hint: --var repo is no longer supported, use --workdir instead)");
+            }
+            else {
+                console.error("Error: --workdir is required. Specify the project directory for this run.");
+            }
+            process.exit(1);
         }
-        // Validate mutual exclusivity: --workdir vs --var repo
-        const repoPath = vars.repo;
-        if (workdir && repoPath) {
-            console.error("--workdir and --var repo=... are mutually exclusive. Use one or the other.");
+        if (vars.repo) {
+            console.error("Error: --var repo is no longer supported. Use --workdir instead.");
             process.exit(1);
         }
         // Validate --workdir exists
-        if (workdir) {
-            const resolvedWorkdir = path.resolve(workdir);
-            if (!fs.existsSync(resolvedWorkdir)) {
-                console.error(`--workdir path does not exist: ${resolvedWorkdir}`);
-                process.exit(1);
-            }
-            if (!fs.statSync(resolvedWorkdir).isDirectory()) {
-                console.error(`--workdir path is not a directory: ${resolvedWorkdir}`);
-                process.exit(1);
-            }
+        const resolvedWorkdir = path.resolve(workdir);
+        if (!fs.existsSync(resolvedWorkdir)) {
+            console.error(`--workdir path does not exist: ${resolvedWorkdir}`);
+            process.exit(1);
+        }
+        if (!fs.statSync(resolvedWorkdir).isDirectory()) {
+            console.error(`--workdir path is not a directory: ${resolvedWorkdir}`);
+            process.exit(1);
         }
         // Validate callback flags after parsing (order-independent)
-        if (noCallback && callbackUrl) {
-            console.error("--no-callback and --callback-url are mutually exclusive.");
+        if (noCallback && (callbackUrl || callbackExec)) {
+            console.error("--no-callback is mutually exclusive with --callback-url and --callback-exec.");
             process.exit(1);
         }
-        if (!noCallback && !callbackUrl) {
-            console.error("Error: No callback configured. Use --callback-url to enable notifications, or --no-callback to run without.");
+        if (!noCallback && !callbackUrl && !callbackExec) {
+            console.error("Error: No callback configured. Use --callback-url and/or --callback-exec, or --no-callback to run without.");
             process.exit(1);
         }
         let callbackConfig;
@@ -217,65 +346,29 @@ async function main() {
                 process.exit(1);
             }
         }
-        const spec = await loadWorkflowSpec(action);
-        // Determine the working directory for the run
-        let effectiveWorkdir;
-        let worktreeMetadata;
-        if (workdir) {
-            // --workdir provided: use it directly, no git operations
-            effectiveWorkdir = path.resolve(workdir);
-        }
-        else if (repoPath) {
-            const resolvedRepo = path.resolve(repoPath);
-            if (noWorktree) {
-                // --no-worktree: work directly in the repo, no worktree creation
-                effectiveWorkdir = resolvedRepo;
+        if (modelFlagSeen) {
+            if (modelOverride === undefined) {
+                console.error("Invalid --model value: missing model name.");
+                process.exit(1);
             }
-            else {
-                // Auto-create worktree (default behavior when repo is provided)
-                const repoInfo = validateGitRepo(resolvedRepo);
-                if (repoInfo.type === 'not-git') {
-                    console.error(`Cannot auto-create worktree: ${resolvedRepo} is not a git repository. Use --workdir instead.`);
-                    process.exit(1);
-                }
-                const shortId = crypto.randomUUID().slice(0, 8);
-                const branch = branchName || `soulforge/${shortId}`;
-                console.log(`Creating worktree with branch: ${branch}`);
-                try {
-                    const result = createWorktree(resolvedRepo, branch, repoInfo);
-                    worktreeMetadata = {
-                        originalRepo: resolvedRepo,
-                        worktreePath: result.worktreePath,
-                        branch: result.branch,
-                    };
-                    effectiveWorkdir = result.worktreePath;
-                    // Install npm dependencies if package.json exists
-                    const packageJsonPath = path.join(result.worktreePath, 'package.json');
-                    if (fs.existsSync(packageJsonPath)) {
-                        console.log("Installing npm dependencies in worktree...");
-                        try {
-                            execSync('npm install', { cwd: result.worktreePath, stdio: 'inherit' });
-                        }
-                        catch {
-                            console.warn("Warning: npm install failed in worktree");
-                        }
-                    }
-                    console.log(`Worktree created at: ${result.worktreePath}`);
-                }
-                catch (err) {
-                    console.error(err instanceof Error ? err.message : String(err));
-                    process.exit(1);
-                }
+            const trimmedModel = modelOverride.trim();
+            if (trimmedModel.length === 0) {
+                console.error("Invalid --model value: model name cannot be empty.");
+                process.exit(1);
             }
-        }
-        // Set workdir variable for templates
-        if (effectiveWorkdir) {
-            vars.workdir = effectiveWorkdir;
-            // Also keep repo pointing to the effective workdir for backwards compatibility
-            if (repoPath) {
-                vars.repo = effectiveWorkdir;
+            if (trimmedModel.startsWith("-")) {
+                console.error(`Invalid --model value "${modelOverride}": model name cannot start with '-'.`);
+                process.exit(1);
             }
+            modelOverride = trimmedModel;
         }
+        const workflowResolution = await resolveWorkflowInput(action);
+        const resolvedWorkflowPath = workflowResolution.path;
+        const spec = await loadWorkflowSpec(resolvedWorkflowPath);
+        // Determine the working directory for the run
+        const effectiveWorkdir = path.resolve(workdir);
+        // Set workdir variable for templates
+        vars.workdir = effectiveWorkdir;
         // Merge vars into context
         if (spec.context) {
             Object.assign(spec.context, vars);
@@ -283,31 +376,106 @@ async function main() {
         else {
             spec.context = vars;
         }
-        // Ensure daemon is running
-        const status = isDaemonRunning();
-        if (!status.running) {
-            console.log("Daemon not running, starting...");
-            startDaemonBackground();
-            // Give daemon a moment to start
-            await new Promise((r) => setTimeout(r, 1000));
-        }
-        const run = createRun(spec, action, task, callbackConfig, worktreeMetadata, executorOverride);
+        // Ensure daemon is running (idempotent singleton auto-start).
+        startDaemonBackground();
+        // Give daemon a moment to start if it was just spawned.
+        await new Promise((r) => setTimeout(r, 1000));
+        const run = createRun(spec, resolvedWorkflowPath, task, callbackConfig, undefined, executorOverride, modelOverride, keepWorktree, callbackExec);
         insertEvent(run.id, "run_started", `Run started: "${task}"`);
         console.log(`Run: ${run.id}`);
         console.log(`Workflow: ${run.workflow_id}`);
         console.log(`Task: ${task}`);
-        if (effectiveWorkdir) {
-            console.log(`Workdir: ${effectiveWorkdir}`);
-        }
+        console.log(`Workdir: ${effectiveWorkdir}`);
         console.log(`Status: ${run.status}`);
         console.log(`\nDaemon will pick up the first step shortly.`);
         console.log(`Track progress: soulforge status ${run.id.slice(0, 8)}`);
         return;
     }
+    // ── Complete command ────────────────────────────────────────────
+    if (group === "complete") {
+        const completeArgs = [action, ...rest].filter((arg) => arg !== undefined);
+        let runId;
+        let stepId;
+        let dataRaw;
+        for (let i = 0; i < completeArgs.length; i += 1) {
+            if (completeArgs[i] === "--run-id" && completeArgs[i + 1]) {
+                runId = completeArgs[i + 1];
+                i += 1;
+            }
+            else if (completeArgs[i] === "--step-id" && completeArgs[i + 1]) {
+                stepId = completeArgs[i + 1];
+                i += 1;
+            }
+            else if (completeArgs[i] === "--data" && completeArgs[i + 1]) {
+                dataRaw = completeArgs[i + 1];
+                i += 1;
+            }
+        }
+        if (!runId || !stepId || dataRaw === undefined) {
+            console.error("Missing required flags. Usage: soulforge complete --run-id <id> --step-id <id> --data '<json>'");
+            process.exit(1);
+        }
+        let data;
+        try {
+            data = JSON.parse(dataRaw);
+        }
+        catch {
+            console.error("Invalid JSON for --data.");
+            process.exit(1);
+        }
+        const run = getRun(runId);
+        if (!run) {
+            console.error(`Run not found: ${runId}`);
+            process.exit(1);
+        }
+        const db = getDb();
+        const step = db.prepare("SELECT id, step_id, output_schema, status FROM steps WHERE run_id = ? AND (step_id = ? OR id = ?) LIMIT 1").get(run.id, stepId, stepId);
+        if (!step) {
+            console.error(`Step not found for run ${run.id}: ${stepId}`);
+            process.exit(1);
+        }
+        if (!step.output_schema) {
+            console.error(`Step "${step.step_id}" does not define output_schema. soulforge complete only supports structured-output steps.`);
+            process.exit(1);
+        }
+        if (step.status !== "running") {
+            console.error(`Step "${step.step_id}" is not running (status: ${step.status}).`);
+            process.exit(1);
+        }
+        const runningStep = db.prepare("SELECT id FROM steps WHERE run_id = ? AND status = 'running' AND step_id = ? LIMIT 1").get(run.id, step.step_id);
+        if (!runningStep || runningStep.id !== step.id) {
+            console.error(`Step "${step.step_id}" is not the running step for this run.`);
+            process.exit(1);
+        }
+        let schema;
+        try {
+            schema = JSON.parse(step.output_schema);
+        }
+        catch {
+            console.error(`Stored output schema for step "${step.step_id}" is invalid JSON.`);
+            process.exit(1);
+        }
+        const validation = validateOutput(data, schema);
+        if (!validation.valid) {
+            console.error("Output validation failed:");
+            for (const error of validation.errors) {
+                console.error(error);
+            }
+            process.exit(1);
+        }
+        updateStepStatus(step.id, "done", { output: JSON.stringify(data) });
+        const runContext = JSON.parse(run.context);
+        if (isPlainObject(data)) {
+            updateRunContext(run.id, { ...runContext, ...data });
+        }
+        console.log(`Completed step "${step.step_id}" for run ${run.id}.`);
+        return;
+    }
     // ── Status command ──────────────────────────────────────────────
     if (group === "status") {
         const query = [action, ...rest].filter(Boolean).join(" ");
         if (!query) {
+            console.log(formatDaemonStatusLine());
             // Show summary of active runs
             const runs = listRuns(10);
             const active = runs.filter((r) => r.status === "running" || r.status === "pending");
@@ -332,7 +500,7 @@ async function main() {
             return;
         }
         const steps = getStepsForRun(run.id);
-        const stories = getStoriesForRun(run.id);
+        const loopItems = getLoopItemsForRun(run.id);
         console.log(`Run: ${run.id}`);
         console.log(`Workflow: ${run.workflow_id}`);
         console.log(`Task: ${run.task.slice(0, 120)}`);
@@ -346,13 +514,13 @@ async function main() {
             const model = s.model ? ` [${s.model}]` : "";
             console.log(`  [${s.status.padEnd(17)}] ${s.step_id} (${s.executor})${model}${dur}`);
         }
-        if (stories.length > 0) {
-            const done = stories.filter((s) => s.status === "done").length;
-            const failed = stories.filter((s) => s.status === "failed").length;
+        if (loopItems.length > 0) {
+            const done = loopItems.filter((s) => s.status === "done").length;
+            const failed = loopItems.filter((s) => s.status === "failed").length;
             console.log();
-            console.log(`Stories: ${done}/${stories.length} done${failed ? `, ${failed} failed` : ""}`);
-            for (const s of stories) {
-                console.log(`  ${s.story_id.padEnd(10)} [${s.status.padEnd(7)}] ${s.title}`);
+            console.log(`Stories: ${done}/${loopItems.length} done${failed ? `, ${failed} failed` : ""}`);
+            for (const s of loopItems) {
+                console.log(`  ${s.item_id.padEnd(10)} [${s.status.padEnd(7)}] ${s.title}`);
             }
         }
         return;
@@ -394,6 +562,44 @@ async function main() {
         // Approve — mark step done and advance
         updateStepStatus(step.id, "done", { output: `APPROVED: ${message}` });
         insertEvent(run.id, "step_complete", `Checkpoint "${step.step_id}" approved: ${message}`, step.step_id);
+        if (step.type === "gate" && step.gate_config) {
+            const gateConfig = JSON.parse(step.gate_config);
+            const runContext = JSON.parse(run.context);
+            const loopCounts = parseGateLoopCounts(runContext.__gate_loop_counts);
+            const gateLoopCount = (loopCounts[step.step_id] ?? 0) + 1;
+            loopCounts[step.step_id] = gateLoopCount;
+            const contextWithLoopCount = {
+                ...runContext,
+                __gate_loop_counts: JSON.stringify(loopCounts),
+            };
+            updateRunContext(run.id, contextWithLoopCount);
+            if (gateLoopCount > gateConfig.max_loops) {
+                const error = `Gate step "${step.step_id}" exceeded max_loops (${gateConfig.max_loops})`;
+                updateStepStatus(step.id, "failed", { error });
+                updateRunStatus(run.id, "failed");
+                insertEvent(run.id, "step_failed", `Step "${step.step_id}" failed: ${error}`, step.step_id, error);
+                insertEvent(run.id, "run_failed", `Run failed at step "${step.step_id}"`, step.step_id, error);
+                console.error(error);
+                process.exit(1);
+            }
+            const decisionValue = getContextValue(contextWithLoopCount, gateConfig.decision_var);
+            const routeStepId = resolveGateRoute(gateConfig, decisionValue);
+            const target = db.prepare("SELECT id FROM steps WHERE run_id = ? AND step_id = ? LIMIT 1").get(run.id, routeStepId);
+            if (!target) {
+                const error = `Gate step "${step.step_id}" resolved route "${routeStepId}" but target step was not found`;
+                updateStepStatus(step.id, "failed", { error });
+                updateRunStatus(run.id, "failed");
+                insertEvent(run.id, "step_failed", `Step "${step.step_id}" failed: ${error}`, step.step_id, error);
+                insertEvent(run.id, "run_failed", `Run failed at step "${step.step_id}"`, step.step_id, error);
+                console.error(error);
+                process.exit(1);
+            }
+            updateStepStatus(target.id, "pending");
+            const detail = `decision_var=${gateConfig.decision_var}, value=${decisionValue ?? "(missing)"}, target=${routeStepId}, loop=${gateLoopCount}/${gateConfig.max_loops}`;
+            insertEvent(run.id, "gate_routed", `Gate "${step.step_id}" routed to "${routeStepId}"`, step.step_id, detail);
+            console.log(`Checkpoint "${step.step_id}" approved. Routed to "${routeStepId}".`);
+            return;
+        }
         const { runCompleted } = advancePipeline(run.id);
         if (runCompleted) {
             insertEvent(run.id, "run_complete", `Run completed: "${run.task}"`);
@@ -482,9 +688,9 @@ async function main() {
         // Reset step to pending
         updateStepStatus(failedStep.id, "pending", { error: null, current_story_id: null });
         updateRunStatus(run.id, "running");
-        // If loop step, reset failed stories
+        // If loop step, reset failed loop_items
         if (failedStep.type === "loop") {
-            db.prepare("UPDATE stories SET status = 'pending', updated_at = ? WHERE run_id = ? AND status = 'failed'").run(new Date().toISOString(), run.id);
+            db.prepare("UPDATE loop_items SET status = 'pending', updated_at = ? WHERE run_id = ? AND status = 'failed'").run(new Date().toISOString(), run.id);
         }
         insertEvent(run.id, "run_resumed", `Run resumed from step "${failedStep.step_id}"`);
         console.log(`Resumed run ${run.id.slice(0, 8)} from step "${failedStep.step_id}".`);