astrocode-workflow 0.2.0 → 0.2.2

package/dist/ui/inject.js

@@ -1,118 +1,95 @@
-// src/ui/inject.ts
-//
-// Deterministic chat injection:
-// - Always enqueue
-// - Process sequentially (per-process single worker)
-// - Retries with backoff
-// - flush() lets callers wait until injections are actually sent
-//
-// IMPORTANT: Callers who need reliability must `await injectChatPrompt(...)`
-// or `await flushChatPrompts()` after enqueueing.
-const injectionQueue = [];
-let workerRunning = false;
-// Used to let callers await "queue drained"
-let drainWaiters = [];
+const MAX_ATTEMPTS = 4;
+const RETRY_DELAYS_MS = [250, 500, 1000, 2000]; // attempt 1..4
+// Per-session queues so one stuck session doesn't block others
+const queues = new Map();
+const running = new Set();
 function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise((r) => setTimeout(r, ms));
 }
-function resolveDrainWaitersIfIdle() {
-    if (workerRunning)
-        return;
-    if (injectionQueue.length !== 0)
-        return;
-    const waiters = drainWaiters;
-    drainWaiters = [];
-    for (const w of waiters)
-        w();
-}
-function getPromptApi(ctx) {
-    const fn = ctx?.client?.session?.prompt;
-    return typeof fn === "function" ? fn.bind(ctx.client.session) : null;
+function getPromptInvoker(ctx) {
+    const session = ctx?.client?.session;
+    const prompt = session?.prompt;
+    if (!session || typeof prompt !== "function") {
+        throw new Error("API not available (ctx.client.session.prompt)");
+    }
+    return { session, prompt };
 }
-async function sendWithRetries(opts) {
-    const { ctx, sessionId, text } = opts;
-    const agent = opts.agent ?? "Astro";
+async function tryInjectOnce(item) {
+    const { ctx, sessionId, text, agent = "Astro" } = item;
     const prefixedText = `[${agent}]\n\n${text}`;
-    if (!sessionId) {
-        console.warn("[Astrocode] Injection skipped: missing sessionId");
-        return;
-    }
-    const prompt = getPromptApi(ctx);
-    if (!prompt) {
-        console.warn("[Astrocode] Injection skipped: ctx.client.session.prompt unavailable");
-        return;
-    }
-    const maxAttempts = 3;
-    let attempt = 0;
-    while (attempt < maxAttempts) {
-        attempt += 1;
-        try {
-            await prompt({
-                path: { id: sessionId },
-                body: {
-                    parts: [{ type: "text", text: prefixedText }],
-                    agent,
-                },
-            });
-            return;
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            const isLast = attempt >= maxAttempts;
-            if (isLast) {
-                console.warn(`[Astrocode] Injection failed (final): ${msg}`);
-                return;
-            }
-            // Exponential backoff + jitter
-            const base = 150 * Math.pow(2, attempt - 1); // 150, 300, 600
-            const jitter = Math.floor(Math.random() * 120);
-            await sleep(base + jitter);
-        }
-    }
+    const { session, prompt } = getPromptInvoker(ctx);
+    // IMPORTANT: force correct `this` binding
+    await prompt.call(session, {
+        path: { id: sessionId },
+        body: {
+            parts: [{ type: "text", text: prefixedText }],
+            agent,
+        },
+    });
 }
-async function runWorkerLoop() {
-    if (workerRunning)
+async function runSessionQueue(sessionId) {
+    if (running.has(sessionId))
         return;
-    workerRunning = true;
+    running.add(sessionId);
     try {
-        // Drain sequentially to preserve ordering
-        while (injectionQueue.length > 0) {
-            const item = injectionQueue.shift();
-            if (!item)
-                continue;
-            await sendWithRetries(item);
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const q = queues.get(sessionId);
+            if (!q || q.length === 0)
+                break;
+            const item = q.shift();
+            try {
+                await tryInjectOnce(item);
+                item.resolve();
+            }
+            catch (err) {
+                item.attempts += 1;
+                const msg = err instanceof Error ? err.message : String(err);
+                const delay = RETRY_DELAYS_MS[Math.min(item.attempts - 1, RETRY_DELAYS_MS.length - 1)] ?? 2000;
+                if (item.attempts >= MAX_ATTEMPTS) {
+                    console.warn(`[Astrocode] Injection failed permanently after ${item.attempts} attempts: ${msg}`);
+                    item.reject(err);
+                    continue;
+                }
+                console.warn(`[Astrocode] Injection attempt ${item.attempts}/${MAX_ATTEMPTS} failed: ${msg}; retrying in ${delay}ms`);
+                await sleep(delay);
+                // Requeue at front to preserve order (and avoid starving later messages)
+                const q2 = queues.get(sessionId) ?? [];
+                q2.unshift(item);
+                queues.set(sessionId, q2);
+            }
         }
     }
     finally {
-        workerRunning = false;
-        resolveDrainWaitersIfIdle();
+        running.delete(sessionId);
     }
 }
 /**
- * Enqueue an injection and ensure the worker is running.
- * Does NOT wait for delivery — use `flushChatPrompts()` to wait.
- */
-export function enqueueChatPrompt(opts) {
-    injectionQueue.push(opts);
-    // Kick worker
-    void runWorkerLoop();
-}
-/**
- * Wait until all queued injections have been processed (sent or exhausted retries).
- */
-export function flushChatPrompts() {
-    if (!workerRunning && injectionQueue.length === 0)
-        return Promise.resolve();
-    return new Promise((resolve) => {
-        drainWaiters.push(resolve);
-        // Ensure worker is running (in case someone enqueued without kick)
-        void runWorkerLoop();
-    });
-}
-/**
- * Deterministic helper: enqueue + flush (recommended for stage boundaries).
+ * Inject a visible prompt into the conversation.
+ * - Deterministic ordering per session
+ * - Correct SDK binding (prevents `this._client` undefined)
+ * - Awaitable: resolves when delivered, rejects after max retries
  */
 export async function injectChatPrompt(opts) {
-    enqueueChatPrompt(opts);
-    await flushChatPrompts();
+    const sessionId = opts.sessionId ?? opts.ctx?.sessionID;
+    if (!sessionId) {
+        console.warn("[Astrocode] Skipping injection: No sessionId provided");
+        return;
+    }
+    return new Promise((resolve, reject) => {
+        const item = {
+            ctx: opts.ctx,
+            sessionId,
+            text: opts.text,
+            agent: opts.agent,
+            attempts: 0,
+            resolve,
+            reject,
+        };
+        const q = queues.get(sessionId) ?? [];
+        q.push(item);
+        queues.set(sessionId, q);
+        // Fire worker (don't await here; caller awaits the returned Promise)
+        void runSessionQueue(sessionId);
+    });
 }

package/dist/workflow/state-machine.d.ts

@@ -1,7 +1,6 @@
 import type { AstrocodeConfig } from "../config/schema";
 import type { SqliteDb } from "../state/db";
 import type { RunRow, StageKey, StageRunRow, StoryRow } from "../state/types";
-import type { ToastOptions } from "../ui/toasts";
 export declare const EVENT_TYPES: {
     readonly RUN_STARTED: "run.started";
     readonly RUN_COMPLETED: "run.completed";
@@ -11,28 +10,39 @@ export declare const EVENT_TYPES: {
     readonly STAGE_STARTED: "stage.started";
     readonly WORKFLOW_PROCEED: "workflow.proceed";
 };
-/**
- * UI HOOKS
- * --------
- * This workflow module is DB-first. UI emission is optional and happens AFTER the DB tx commits.
- *
- * Contract:
- * - If you pass ui.ctx + ui.sessionId, we will inject a visible chat message deterministically.
- * - If you pass ui.toast, we will also toast (throttling is handled by the toast manager).
- */
-export type WorkflowUi = {
-    ctx: any;
-    sessionId: string;
-    agentName?: string;
-    toast?: (t: ToastOptions) => Promise<void>;
+export type UiEmitEvent = {
+    kind: "stage_started";
+    run_id: string;
+    stage_key: StageKey;
+    agent_name?: string;
+} | {
+    kind: "run_completed";
+    run_id: string;
+    story_key: string;
+} | {
+    kind: "run_failed";
+    run_id: string;
+    story_key: string;
+    stage_key: StageKey;
+    error_text: string;
 };
+export type UiEmit = (e: UiEmitEvent) => void;
 /**
  * PLANNING-FIRST REDESIGN
  * ----------------------
- * - Never mutate story title/body.
- * - Planning-first becomes a run-scoped inject stored in `injects` (scope = run:<run_id>).
- * - Trigger is deterministic via config.workflow.genesis_planning:
- *    - "off" | "first_story_only" | "always"
+ * Never mutate story title/body.
+ *
+ * Deterministic trigger:
+ * - config.workflow.genesis_planning:
+ *    - "off"             => never attach directive
+ *    - "first_story_only"=> only when story_key === "S-0001"
+ *    - "always"          => attach for every run
+ *
+ * Contract: DB is already initialized before workflow is used:
+ * - schema tables exist
+ * - repo_state singleton row (id=1) exists
+ *
+ * IMPORTANT: Do NOT call withTx() in here. The caller owns transaction boundaries.
  */
 export type NextAction = {
     kind: "idle";
@@ -67,20 +77,10 @@ export declare function decideNextAction(db: SqliteDb, config: AstrocodeConfig):
 export declare function createRunForStory(db: SqliteDb, config: AstrocodeConfig, storyKey: string): {
     run_id: string;
 };
-/**
- * STAGE MOVEMENT (START) — now async so UI injection is deterministic.
- */
 export declare function startStage(db: SqliteDb, runId: string, stageKey: StageKey, meta?: {
     subagent_type?: string;
     subagent_session_id?: string;
-    ui?: WorkflowUi;
-}): Promise<void>;
-/**
- * STAGE CLOSED (RUN COMPLETED) — now async so UI injection is deterministic.
- */
-export declare function completeRun(db: SqliteDb, runId: string, ui?: WorkflowUi): Promise<void>;
-/**
- * STAGE CLOSED (RUN FAILED) — now async so UI injection is deterministic.
- */
-export declare function failRun(db: SqliteDb, runId: string, stageKey: StageKey, errorText: string, ui?: WorkflowUi): Promise<void>;
+}, emit?: UiEmit): void;
+export declare function completeRun(db: SqliteDb, runId: string, emit?: UiEmit): void;
+export declare function failRun(db: SqliteDb, runId: string, stageKey: StageKey, errorText: string, emit?: UiEmit): void;
 export declare function abortRun(db: SqliteDb, runId: string, reason: string): void;

package/dist/workflow/state-machine.js

@@ -1,10 +1,8 @@
-import { withTx } from "../state/db";
 import { nowISO } from "../shared/time";
 import { newEventId, newRunId, newStageRunId } from "../state/ids";
 import { warn } from "../shared/log";
 import { sha256Hex } from "../shared/hash";
 import { SCHEMA_VERSION } from "../state/schema";
-import { injectChatPrompt } from "../ui/inject";
 export const EVENT_TYPES = {
     RUN_STARTED: "run.started",
     RUN_COMPLETED: "run.completed",
@@ -14,31 +12,6 @@ export const EVENT_TYPES = {
     STAGE_STARTED: "stage.started",
     WORKFLOW_PROCEED: "workflow.proceed",
 };
-async function emitUi(ui, text, toast) {
-    if (!ui)
-        return;
-    // Prefer toast (if provided) AND also inject chat (for audit trail / visibility).
-    // If you want toast-only, pass a toast function and omit ctx/sessionId.
-    if (toast && ui.toast) {
-        try {
-            await ui.toast(toast);
-        }
-        catch {
-            // non-fatal
-        }
-    }
-    try {
-        await injectChatPrompt({
-            ctx: ui.ctx,
-            sessionId: ui.sessionId,
-            text,
-            agent: ui.agentName ?? "Astro",
-        });
-    }
-    catch {
-        // non-fatal (workflow correctness is DB-based)
-    }
-}
 function tableExists(db, tableName) {
     try {
         const row = db
@@ -90,7 +63,7 @@ export function decideNextAction(db, config) {
     if (current.status === "failed") {
         return { kind: "failed", run_id: activeRun.run_id, stage_key: current.stage_key, error_text: current.error_text ?? "stage failed" };
     }
-    warn("Unexpected stage status in decideNextAction", { status: current.status, stage_key: current.status });
+    warn("Unexpected stage status in decideNextAction", { status: current.status, stage_key: current.stage_key });
     return { kind: "await_stage_completion", run_id: activeRun.run_id, stage_key: current.stage_key, stage_run_id: current.stage_run_id };
 }
 function getPipelineFromConfig(config) {
@@ -153,149 +126,91 @@ function attachRunPlanningDirective(db, runId, story, pipeline) {
     }
 }
 export function createRunForStory(db, config, storyKey) {
-    return withTx(db, () => {
-        const story = getStory(db, storyKey);
-        if (!story)
-            throw new Error(`Story not found: ${storyKey}`);
-        if (story.state !== "approved")
-            throw new Error(`Story must be approved to run: ${storyKey} (state=${story.state})`);
-        const run_id = newRunId();
-        const now = nowISO();
-        const pipeline = getPipelineFromConfig(config);
-        db.prepare("UPDATE stories SET state='in_progress', in_progress=1, locked_by_run_id=?, locked_at=?, updated_at=? WHERE story_key=?").run(run_id, now, now, storyKey);
-        db.prepare("INSERT INTO runs (run_id, story_key, status, pipeline_stages_json, current_stage_key, created_at, started_at, updated_at) VALUES (?, ?, 'running', ?, ?, ?, ?, ?)").run(run_id, storyKey, JSON.stringify(pipeline), pipeline[0] ?? null, now, now, now);
-        const insertStage = db.prepare("INSERT INTO stage_runs (stage_run_id, run_id, stage_key, stage_index, status, created_at, updated_at) VALUES (?, ?, ?, ?, 'pending', ?, ?)");
-        pipeline.forEach((stageKey, idx) => {
-            insertStage.run(newStageRunId(), run_id, stageKey, idx, now, now);
-        });
-        db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, NULL, ?, ?, ?)").run(newEventId(), run_id, EVENT_TYPES.RUN_STARTED, JSON.stringify({ story_key: storyKey, pipeline }), now);
-        if (shouldAttachPlanningDirective(config, story)) {
-            attachRunPlanningDirective(db, run_id, story, pipeline);
-        }
-        db.prepare(`
-      INSERT INTO repo_state (id, schema_version, created_at, updated_at, last_run_id, last_story_key, last_event_at)
-      VALUES (1, ?, ?, ?, ?, ?, ?)
-      ON CONFLICT(id) DO UPDATE SET
-        last_run_id=excluded.last_run_id,
-        last_story_key=excluded.last_story_key,
-        last_event_at=excluded.last_event_at,
-        updated_at=excluded.updated_at
-    `).run(SCHEMA_VERSION, now, now, run_id, storyKey, now);
-        return { run_id };
-    });
-}
-/**
- * STAGE MOVEMENT (START) — now async so UI injection is deterministic.
- */
-export async function startStage(db, runId, stageKey, meta) {
-    // Do DB work inside tx, capture what we need for UI outside.
-    const payload = withTx(db, () => {
-        const now = nowISO();
-        const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId);
-        if (!run)
-            throw new Error(`Run not found: ${runId}`);
-        if (run.status !== "running")
-            throw new Error(`Run is not running: ${runId} (status=${run.status})`);
-        const stage = db.prepare("SELECT * FROM stage_runs WHERE run_id=? AND stage_key=?").get(runId, stageKey);
-        if (!stage)
-            throw new Error(`Stage run not found: ${runId}/${stageKey}`);
-        if (stage.status !== "pending")
-            throw new Error(`Stage is not pending: ${stageKey} (status=${stage.status})`);
-        db.prepare("UPDATE stage_runs SET status='running', started_at=?, updated_at=?, subagent_type=COALESCE(?, subagent_type), subagent_session_id=COALESCE(?, subagent_session_id) WHERE stage_run_id=?").run(now, now, meta?.subagent_type ?? null, meta?.subagent_session_id ?? null, stage.stage_run_id);
-        db.prepare("UPDATE runs SET current_stage_key=?, updated_at=? WHERE run_id=?").run(stageKey, now, runId);
-        db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, ?, ?, ?, ?)").run(newEventId(), runId, stageKey, EVENT_TYPES.STAGE_STARTED, JSON.stringify({ subagent_type: meta?.subagent_type ?? null }), now);
-        db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
-        const story = db.prepare("SELECT story_key, title FROM stories WHERE story_key=?").get(run.story_key);
-        return {
-            now,
-            story_key: run.story_key,
-            story_title: story?.title ?? "",
-        };
-    });
-    // Deterministic UI emission AFTER commit (never inside tx).
-    await emitUi(meta?.ui, [
-        `🟦 Stage started`,
-        `- Run: \`${runId}\``,
-        `- Stage: \`${stageKey}\``,
-        `- Story: \`${payload.story_key}\` — ${payload.story_title || "(untitled)"}`,
-    ].join("\n"), {
-        title: "Stage started",
-        message: `${stageKey} (${payload.story_key})`,
-        variant: "info",
-        durationMs: 2500,
-    });
-}
-/**
- * STAGE CLOSED (RUN COMPLETED) — now async so UI injection is deterministic.
- */
-export async function completeRun(db, runId, ui) {
-    const payload = withTx(db, () => {
-        const now = nowISO();
-        const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId);
-        if (!run)
-            throw new Error(`Run not found: ${runId}`);
-        if (run.status !== "running")
-            throw new Error(`Run not running: ${runId} (status=${run.status})`);
-        const stageRuns = getStageRuns(db, runId);
-        const incomplete = stageRuns.find((s) => s.status !== "completed" && s.status !== "skipped");
-        if (incomplete)
-            throw new Error(`Cannot complete run: stage ${incomplete.stage_key} is ${incomplete.status}`);
-        db.prepare("UPDATE runs SET status='completed', completed_at=?, updated_at=?, current_stage_key=NULL WHERE run_id=?").run(now, now, runId);
-        db.prepare("UPDATE stories SET state='done', in_progress=0, locked_by_run_id=NULL, locked_at=NULL, updated_at=? WHERE story_key=?").run(now, run.story_key);
-        db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, NULL, ?, ?, ?)").run(newEventId(), runId, EVENT_TYPES.RUN_COMPLETED, JSON.stringify({ story_key: run.story_key }), now);
-        db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
-        const story = db.prepare("SELECT story_key, title FROM stories WHERE story_key=?").get(run.story_key);
-        return { now, story_key: run.story_key, story_title: story?.title ?? "" };
-    });
-    await emitUi(ui, [
-        `✅ Run completed`,
-        `- Run: \`${runId}\``,
-        `- Story: \`${payload.story_key}\` — ${payload.story_title || "(untitled)"}`,
-    ].join("\n"), {
-        title: "Run completed",
-        message: `${payload.story_key} — done`,
-        variant: "success",
-        durationMs: 3000,
-    });
-}
-/**
- * STAGE CLOSED (RUN FAILED) — now async so UI injection is deterministic.
- */
-export async function failRun(db, runId, stageKey, errorText, ui) {
-    const payload = withTx(db, () => {
-        const now = nowISO();
-        const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId);
-        if (!run)
-            throw new Error(`Run not found: ${runId}`);
-        db.prepare("UPDATE runs SET status='failed', error_text=?, updated_at=?, completed_at=? WHERE run_id=?").run(errorText, now, now, runId);
-        db.prepare("UPDATE stories SET state='blocked', in_progress=0, locked_by_run_id=NULL, locked_at=NULL, updated_at=? WHERE story_key=?").run(now, run.story_key);
-        db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, ?, ?, ?, ?)").run(newEventId(), runId, stageKey, EVENT_TYPES.RUN_FAILED, JSON.stringify({ error_text: errorText }), now);
-        db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
-        const story = db.prepare("SELECT story_key, title FROM stories WHERE story_key=?").get(run.story_key);
-        return { now, story_key: run.story_key, story_title: story?.title ?? "" };
-    });
-    await emitUi(ui, [
-        `⛔ Run failed`,
-        `- Run: \`${runId}\``,
-        `- Stage: \`${stageKey}\``,
-        `- Story: \`${payload.story_key}\` — ${payload.story_title || "(untitled)"}`,
-        `- Error: ${errorText}`,
-    ].join("\n"), {
-        title: "Run failed",
-        message: `${stageKey}: ${errorText}`,
-        variant: "error",
-        durationMs: 4500,
+    const story = getStory(db, storyKey);
+    if (!story)
+        throw new Error(`Story not found: ${storyKey}`);
+    if (story.state !== "approved")
+        throw new Error(`Story must be approved to run: ${storyKey} (state=${story.state})`);
+    const run_id = newRunId();
+    const now = nowISO();
+    const pipeline = getPipelineFromConfig(config);
+    db.prepare("UPDATE stories SET state='in_progress', in_progress=1, locked_by_run_id=?, locked_at=?, updated_at=? WHERE story_key=?").run(run_id, now, now, storyKey);
+    db.prepare("INSERT INTO runs (run_id, story_key, status, pipeline_stages_json, current_stage_key, created_at, started_at, updated_at) VALUES (?, ?, 'running', ?, ?, ?, ?, ?)").run(run_id, storyKey, JSON.stringify(pipeline), pipeline[0] ?? null, now, now, now);
+    const insertStage = db.prepare("INSERT INTO stage_runs (stage_run_id, run_id, stage_key, stage_index, status, created_at, updated_at) VALUES (?, ?, ?, ?, 'pending', ?, ?)");
+    pipeline.forEach((stageKey, idx) => {
+        insertStage.run(newStageRunId(), run_id, stageKey, idx, now, now);
     });
+    db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, NULL, ?, ?, ?)").run(newEventId(), run_id, EVENT_TYPES.RUN_STARTED, JSON.stringify({ story_key: storyKey, pipeline }), now);
+    if (shouldAttachPlanningDirective(config, story)) {
+        attachRunPlanningDirective(db, run_id, story, pipeline);
+    }
+    db.prepare(`
+    INSERT INTO repo_state (id, schema_version, created_at, updated_at, last_run_id, last_story_key, last_event_at)
+    VALUES (1, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET
+      last_run_id=excluded.last_run_id,
+      last_story_key=excluded.last_story_key,
+      last_event_at=excluded.last_event_at,
+      updated_at=excluded.updated_at
+  `).run(SCHEMA_VERSION, now, now, now, run_id, storyKey, now);
+    return { run_id };
+}
+export function startStage(db, runId, stageKey, meta, emit) {
+    const now = nowISO();
+    const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId);
+    if (!run)
+        throw new Error(`Run not found: ${runId}`);
+    if (run.status !== "running")
+        throw new Error(`Run is not running: ${runId} (status=${run.status})`);
+    const stage = db.prepare("SELECT * FROM stage_runs WHERE run_id=? AND stage_key=?").get(runId, stageKey);
+    if (!stage)
+        throw new Error(`Stage run not found: ${runId}/${stageKey}`);
+    if (stage.status !== "pending")
+        throw new Error(`Stage is not pending: ${stageKey} (status=${stage.status})`);
+    db.prepare("UPDATE stage_runs SET status='running', started_at=?, updated_at=?, subagent_type=COALESCE(?, subagent_type), subagent_session_id=COALESCE(?, subagent_session_id) WHERE stage_run_id=?").run(now, now, meta?.subagent_type ?? null, meta?.subagent_session_id ?? null, stage.stage_run_id);
+    db.prepare("UPDATE runs SET current_stage_key=?, updated_at=? WHERE run_id=?").run(stageKey, now, runId);
+    db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, ?, ?, ?, ?)").run(newEventId(), runId, stageKey, EVENT_TYPES.STAGE_STARTED, JSON.stringify({ subagent_type: meta?.subagent_type ?? null }), now);
+    db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
+    // ✅ Explicit wiring point (requested): stage movement
+    emit?.({ kind: "stage_started", run_id: runId, stage_key: stageKey, agent_name: meta?.subagent_type });
+}
+export function completeRun(db, runId, emit) {
+    const now = nowISO();
+    const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId);
+    if (!run)
+        throw new Error(`Run not found: ${runId}`);
+    if (run.status !== "running")
+        throw new Error(`Run not running: ${runId} (status=${run.status})`);
+    const stageRuns = getStageRuns(db, runId);
+    const incomplete = stageRuns.find((s) => s.status !== "completed" && s.status !== "skipped");
+    if (incomplete)
+        throw new Error(`Cannot complete run: stage ${incomplete.stage_key} is ${incomplete.status}`);
+    db.prepare("UPDATE runs SET status='completed', completed_at=?, updated_at=?, current_stage_key=NULL WHERE run_id=?").run(now, now, runId);
+    db.prepare("UPDATE stories SET state='done', in_progress=0, locked_by_run_id=NULL, locked_at=NULL, updated_at=? WHERE story_key=?").run(now, run.story_key);
+    db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, NULL, ?, ?, ?)").run(newEventId(), runId, EVENT_TYPES.RUN_COMPLETED, JSON.stringify({ story_key: run.story_key }), now);
+    db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
+    // ✅ Explicit wiring point (requested): run closed success
+    emit?.({ kind: "run_completed", run_id: runId, story_key: run.story_key });
+}
+export function failRun(db, runId, stageKey, errorText, emit) {
+    const now = nowISO();
+    const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId);
+    if (!run)
+        throw new Error(`Run not found: ${runId}`);
+    db.prepare("UPDATE runs SET status='failed', error_text=?, updated_at=?, completed_at=? WHERE run_id=?").run(errorText, now, now, runId);
+    db.prepare("UPDATE stories SET state='blocked', in_progress=0, locked_by_run_id=NULL, locked_at=NULL, updated_at=? WHERE story_key=?").run(now, run.story_key);
+    db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, ?, ?, ?, ?)").run(newEventId(), runId, stageKey, EVENT_TYPES.RUN_FAILED, JSON.stringify({ error_text: errorText }), now);
+    db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
+    // ✅ Explicit wiring point (requested): run closed failure
+    emit?.({ kind: "run_failed", run_id: runId, story_key: run.story_key, stage_key: stageKey, error_text: errorText });
 }
 export function abortRun(db, runId, reason) {
-    return withTx(db, () => {
-        const now = nowISO();
-        const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId);
-        if (!run)
-            throw new Error(`Run not found: ${runId}`);
-        db.prepare("UPDATE runs SET status='aborted', error_text=?, updated_at=?, completed_at=? WHERE run_id=?").run(reason, now, now, runId);
-        db.prepare("UPDATE stories SET state='approved', in_progress=0, locked_by_run_id=NULL, locked_at=NULL, updated_at=? WHERE story_key=?").run(now, run.story_key);
-        db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, NULL, ?, ?, ?)").run(newEventId(), runId, EVENT_TYPES.RUN_ABORTED, JSON.stringify({ reason }), now);
-        db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
-    });
+    const now = nowISO();
+    const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId);
+    if (!run)
+        throw new Error(`Run not found: ${runId}`);
+    db.prepare("UPDATE runs SET status='aborted', error_text=?, updated_at=?, completed_at=? WHERE run_id=?").run(reason, now, now, runId);
+    db.prepare("UPDATE stories SET state='approved', in_progress=0, locked_by_run_id=NULL, locked_at=NULL, updated_at=? WHERE story_key=?").run(now, run.story_key);
+    db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, NULL, ?, ?, ?)").run(newEventId(), runId, EVENT_TYPES.RUN_ABORTED, JSON.stringify({ reason }), now);
+    db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astrocode-workflow",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -13,6 +13,7 @@ import { createToastManager, type ToastOptions } from "./ui/toasts";
 import { createAstroAgents } from "./agents/registry";
 import type { AgentConfig } from "@opencode-ai/sdk";
 import { info, warn } from "./shared/log";
+import { acquireRepoLock } from "./state/repo-lock";
 
 // Type definitions for plugin components
 type ConfigHandler = (config: Record<string, any>) => Promise<void>;
@@ -58,6 +59,10 @@ const Astrocode: Plugin = async (ctx) => {
   }
   const repoRoot = ctx.directory;
 
+  // Acquire exclusive repo lock to prevent multiple processes from corrupting the database
+  const lockPath = `${repoRoot}/.astro/astro.lock`;
+  const repoLock = acquireRepoLock(lockPath);
+
   // Always load config first - this provides defaults even in limited mode
   let pluginConfig: AstrocodeConfig;
   try {
@@ -325,6 +330,9 @@ const Astrocode: Plugin = async (ctx) => {
 
     // Best-effort cleanup
     close: async () => {
+      // Release repo lock first (important for process termination)
+      repoLock.release();
+
       if (db && typeof db.close === "function") {
         try {
           db.close();