astrocode-workflow 0.3.0 → 0.3.2

package/src/ui/inject.ts

@@ -1,107 +1,141 @@
 // src/ui/inject.ts
-
-let isInjecting = false;
-
-const injectionQueue: Array<{
+import { recordInjection, recordError } from "../shared/metrics";
+type InjectionItem = {
   ctx: any;
-  sessionId?: string;
+  sessionId: string;
   text: string;
   agent?: string;
-  toast?: { title: string; message: string; variant?: "info" | "success" | "warning" | "error"; durationMs?: number };
-  retry?: { maxAttempts?: number; baseDelayMs?: number };
-}> = [];
+  attempts: number;
+  resolve: () => void;
+  reject: (err: any) => void;
+};
+
+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<string, InjectionItem[]>();
+const running = new Set<string>();
 
 function sleep(ms: number) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
-function resolveSessionId(ctx: any, sessionId?: string): string | null {
-  if (sessionId) return sessionId;
-  const direct = (ctx as any)?.sessionID ?? (ctx as any)?.sessionId ?? (ctx as any)?.session?.id;
-  if (typeof direct === "string" && direct.length > 0) return direct;
-  return null;
-}
-
-async function tryInjectOnce(opts: { ctx: any; sessionId: string; text: string; agent: string }): Promise<void> {
-  const { ctx, sessionId, text, agent } = opts;
-
-  // Prefer explicit chat prompt API
-  const promptApi = (ctx as any)?.client?.session?.prompt;
-  if (!promptApi) {
+function getPromptInvoker(ctx: any): { session: any; prompt: Function } {
+  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: InjectionItem): Promise<void> {
+  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();
 
-async function processQueue() {
-  if (isInjecting) return;
-  if (injectionQueue.length === 0) return;
+  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;
+  }
+}
 
-  isInjecting = true;
+async function runSessionQueue(sessionId: string) {
+  if (running.has(sessionId)) return;
+  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;
-      }
-
-      const maxAttempts = item.retry?.maxAttempts ?? 4;
-      const baseDelayMs = item.retry?.baseDelayMs ?? 250;
-
-      let lastErr: any = 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);
+    // 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}`
+          );
+          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);
   }
 }
 
-export async function injectChatPrompt(opts: { ctx: any; sessionId?: string; text: string; agent?: string }) {
-  injectionQueue.push({
-    ctx: opts.ctx,
-    sessionId: opts.sessionId,
-    text: opts.text,
-    agent: opts.agent ?? "Astro",
-    retry: { maxAttempts: 4, baseDelayMs: 250 },
-  });
+/**
+ * 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: {
+  ctx: any;
+  sessionId?: string;
+  text: string;
+  agent?: string;
+}): Promise<void> {
+  const sessionId = opts.sessionId ?? (opts.ctx as any)?.sessionID;
+  if (!sessionId) {
+    console.warn("[Astrocode] Skipping injection: No sessionId provided");
+    return;
+  }
 
-  // Fire-and-forget; queue drain is serialized by isInjecting.
-  void processQueue();
+  return new Promise<void>((resolve, reject) => {
+    const item: InjectionItem = {
+      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/src/workflow/state-machine.ts

@@ -1,15 +1,12 @@
 // src/workflow/state-machine.ts
 import type { AstrocodeConfig } from "../config/schema";
 import type { SqliteDb } from "../state/db";
-import { withTx } from "../state/db";
 import type { RunRow, StageKey, StageRunRow, StoryRow } from "../state/types";
 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 type { ToastOptions } from "../ui/toasts";
-import { injectChatPrompt } from "../ui/inject";
 
 export const EVENT_TYPES = {
   RUN_STARTED: "run.started",
@@ -21,47 +18,6 @@ export const EVENT_TYPES = {
   WORKFLOW_PROCEED: "workflow.proceed",
 } as const;
 
-/**
- * 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; // label for injected chat messages
-  toast?: (t: ToastOptions) => Promise<void>;
-};
-
-async function emitUi(ui: WorkflowUi | undefined, text: string, toast?: ToastOptions): Promise<void> {
-  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: SqliteDb, tableName: string): boolean {
   try {
     const row = db
@@ -73,14 +29,31 @@ function tableExists(db: SqliteDb, tableName: string): boolean {
   }
 }
 
+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"; reason: "no_approved_stories" }
   | { kind: "start_run"; story_key: string }
@@ -141,7 +114,7 @@ export function decideNextAction(db: SqliteDb, config: AstrocodeConfig): NextAct
     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 };
 }
 
@@ -215,221 +188,144 @@ function attachRunPlanningDirective(db: SqliteDb, runId: string, story: StoryRow
 }
 
 export function createRunForStory(db: SqliteDb, config: AstrocodeConfig, storyKey: string): { run_id: string } {
-  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 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);
+  const run_id = newRunId();
+  const now = nowISO();
+  const pipeline = getPipelineFromConfig(config);
 
-    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);
+  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);
 
-    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 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);
 
-    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 };
+  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 };
 }
 
-/**
- * STAGE MOVEMENT (START) — now async so UI injection is deterministic.
- */
-export async function startStage(
+export function startStage(
   db: SqliteDb,
   runId: string,
   stageKey: StageKey,
-  meta?: { subagent_type?: string; subagent_session_id?: string; ui?: WorkflowUi }
-): Promise<void> {
-  // 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) as RunRow | undefined;
-    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) as StageRunRow | undefined;
-    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})`);
+  meta?: { subagent_type?: string; subagent_session_id?: string },
+  emit?: UiEmit
+) {
+  const now = nowISO();
 
-    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);
+  const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId) as RunRow | undefined;
+  if (!run) throw new Error(`Run not found: ${runId}`);
+  if (run.status !== "running") throw new Error(`Run is not running: ${runId} (status=${run.status})`);
 
-    db.prepare("UPDATE runs SET current_stage_key=?, updated_at=? WHERE run_id=?").run(stageKey, now, runId);
+  const stage = db.prepare("SELECT * FROM stage_runs WHERE run_id=? AND stage_key=?").get(runId, stageKey) as StageRunRow | undefined;
+  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(
-      "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 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 repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
+  db.prepare("UPDATE runs SET current_stage_key=?, updated_at=? WHERE run_id=?").run(stageKey, now, runId);
 
-    const story = db.prepare("SELECT story_key, title FROM stories WHERE story_key=?").get(run.story_key) as any;
+  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);
 
-    return {
-      now,
-      story_key: run.story_key,
-      story_title: story?.title ?? "",
-    };
-  });
+  db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
 
-  // 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,
-    }
-  );
+  // ✅ Explicit wiring point (requested): stage movement
+  emit?.({ kind: "stage_started", run_id: runId, stage_key: stageKey, agent_name: meta?.subagent_type });
 }
 
-/**
- * STAGE CLOSED (RUN COMPLETED) — now async so UI injection is deterministic.
- */
-export async function completeRun(db: SqliteDb, runId: string, ui?: WorkflowUi): Promise<void> {
-  const payload = withTx(db, () => {
-    const now = nowISO();
-
-    const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId) as RunRow | undefined;
-    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);
+export function completeRun(db: SqliteDb, runId: string, emit?: UiEmit) {
+  const now = nowISO();
+  const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId) as RunRow | undefined;
+  if (!run) throw new Error(`Run not found: ${runId}`);
+  if (run.status !== "running") throw new Error(`Run not running: ${runId} (status=${run.status})`);
 
-    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);
+  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(
-      "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 runs SET status='completed', completed_at=?, updated_at=?, current_stage_key=NULL WHERE run_id=?").run(now, now, runId);
 
-    db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
+  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);
 
-    const story = db.prepare("SELECT story_key, title FROM stories WHERE story_key=?").get(run.story_key) as any;
+  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);
 
-    return { now, story_key: run.story_key, story_title: story?.title ?? "" };
-  });
+  db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
 
-  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,
-    }
-  );
+  // ✅ Explicit wiring point (requested): run closed success
+  emit?.({ kind: "run_completed", run_id: runId, story_key: run.story_key });
 }
 
-/**
- * STAGE CLOSED (RUN FAILED) — now async so UI injection is deterministic.
- */
-export async function failRun(db: SqliteDb, runId: string, stageKey: StageKey, errorText: string, ui?: WorkflowUi): Promise<void> {
-  const payload = withTx(db, () => {
-    const now = nowISO();
-
-    const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId) as RunRow | undefined;
-    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);
+export function failRun(db: SqliteDb, runId: string, stageKey: StageKey, errorText: string, emit?: UiEmit) {
+  const now = nowISO();
+  const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId) as RunRow | undefined;
+  if (!run) throw new Error(`Run not found: ${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("UPDATE runs SET status='failed', error_text=?, updated_at=?, completed_at=? WHERE run_id=?").run(errorText, now, 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.RUN_FAILED, JSON.stringify({ error_text: errorText }), now);
+  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("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
+  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);
 
-    const story = db.prepare("SELECT story_key, title FROM stories WHERE story_key=?").get(run.story_key) as any;
+  db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
 
-    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,
-    }
-  );
+  // ✅ 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: SqliteDb, runId: string, reason: string) {
-  return withTx(db, () => {
-    const now = nowISO();
-    const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId) as RunRow | undefined;
-    if (!run) throw new Error(`Run not found: ${runId}`);
+  const now = nowISO();
+  const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId) as RunRow | undefined;
+  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 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(
+    "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(
+    "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);
-  });
+  db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
 }