astrocode-workflow 0.2.0 → 0.2.2

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