astrocode-workflow 0.3.0 → 0.3.2

package/dist/ui/inject.js

@@ -1,88 +1,107 @@
 // src/ui/inject.ts
-let isInjecting = false;
-const injectionQueue = [];
+import { recordInjection, recordError } from "../shared/metrics";
+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((r) => setTimeout(r, ms));
 }
-function resolveSessionId(ctx, sessionId) {
-    if (sessionId)
-        return sessionId;
-    const direct = ctx?.sessionID ?? ctx?.sessionId ?? ctx?.session?.id;
-    if (typeof direct === "string" && direct.length > 0)
-        return direct;
-    return null;
-}
-async function tryInjectOnce(opts) {
-    const { ctx, sessionId, text, agent } = opts;
-    // Prefer explicit chat prompt API
-    const promptApi = ctx?.client?.session?.prompt;
-    if (!promptApi) {
+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 tryInjectOnce(item) {
+    const { ctx, sessionId, text, agent = "Astro" } = item;
     const prefixedText = `[${agent}]\n\n${text}`;
-    // Some hosts reject unknown fields; keep body minimal and stable.
-    await promptApi({
-        path: { id: sessionId },
-        body: {
-            parts: [{ type: "text", text: prefixedText }],
-        },
-    });
+    const injectionRecorder = recordInjection({ sessionId, attempts: item.attempts + 1, agent });
+    const injectionStart = injectionRecorder.start();
+    try {
+        const { session, prompt } = getPromptInvoker(ctx);
+        // IMPORTANT: force correct `this` binding
+        await prompt.call(session, {
+            path: { id: sessionId },
+            body: {
+                parts: [{ type: "text", text: prefixedText }],
+                agent,
+            },
+        });
+        injectionRecorder.end(injectionStart, true);
+    }
+    catch (error) {
+        injectionRecorder.end(injectionStart, false);
+        throw error;
+    }
 }
-async function processQueue() {
-    if (isInjecting)
+async function runSessionQueue(sessionId) {
+    if (running.has(sessionId))
         return;
-    if (injectionQueue.length === 0)
-        return;
-    isInjecting = true;
+    running.add(sessionId);
     try {
-        while (injectionQueue.length > 0) {
-            const item = injectionQueue.shift();
-            if (!item)
-                continue;
-            const { ctx, text, agent = "Astro" } = item;
-            const sessionId = resolveSessionId(ctx, item.sessionId);
-            if (!sessionId) {
-                // Drop on floor: we cannot recover without a session id.
-                // Keep draining the queue so we don't stall.
-                // eslint-disable-next-line no-console
-                console.warn("[Astrocode] Injection skipped: no sessionId");
-                continue;
+        // 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();
             }
-            const maxAttempts = item.retry?.maxAttempts ?? 4;
-            const baseDelayMs = item.retry?.baseDelayMs ?? 250;
-            let lastErr = null;
-            for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-                try {
-                    await tryInjectOnce({ ctx, sessionId, text, agent });
-                    lastErr = null;
-                    break;
-                }
-                catch (e) {
-                    lastErr = e;
-                    const delay = baseDelayMs * Math.pow(2, attempt - 1); // 250, 500, 1000, 2000
-                    // eslint-disable-next-line no-console
-                    console.warn(`[Astrocode] Injection attempt ${attempt}/${maxAttempts} failed: ${String(e)}; retrying in ${delay}ms`);
-                    await sleep(delay);
+            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}`);
+                    recordError("injection_failure", `Injection failed after ${item.attempts} attempts: ${msg}`);
+                    item.reject(err);
+                    continue;
                 }
-            }
-            if (lastErr) {
-                // eslint-disable-next-line no-console
-                console.warn(`[Astrocode] Injection failed permanently after ${maxAttempts} attempts: ${String(lastErr)}`);
+                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 {
-        isInjecting = false;
+        running.delete(sessionId);
     }
 }
+/**
+ * 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) {
-    injectionQueue.push({
-        ctx: opts.ctx,
-        sessionId: opts.sessionId,
-        text: opts.text,
-        agent: opts.agent ?? "Astro",
-        retry: { maxAttempts: 4, baseDelayMs: 250 },
+    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);
     });
-    // Fire-and-forget; queue drain is serialized by isInjecting.
-    void processQueue();
 }

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.3.0",
+  "version": "0.3.2",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,7 +13,9 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "clean": "rm -rf dist"
+    "clean": "rm -rf dist",
+    "test": "vitest",
+    "test:run": "vitest run"
   },
   "dependencies": {
     "@opencode-ai/plugin": "^1.1.19",
@@ -28,6 +30,7 @@
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.12",
     "@types/node": "^20.12.12",
-    "typescript": "^5.6.3"
+    "typescript": "^5.6.3",
+    "vitest": "^1.6.0"
   }
 }

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();