astrocode-workflow 0.1.59 → 0.2.1

package/src/workflow/state-machine.ts

@@ -1,12 +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";
 
 export const EVENT_TYPES = {
   RUN_STARTED: "run.started",
@@ -18,23 +18,40 @@ export const EVENT_TYPES = {
   WORKFLOW_PROCEED: "workflow.proceed",
 } as const;
 
+function tableExists(db: SqliteDb, tableName: string): boolean {
+  try {
+    const row = db
+      .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?")
+      .get(tableName) as { name?: string } | undefined;
+    return row?.name === tableName;
+  } catch {
+    return false;
+  }
+}
+
+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
  * ----------------------
- * Old behavior: mutate an approved story into a planning/decomposition instruction.
- * New behavior: NEVER mutate story title/body.
- *
- * Planning-first is a run-scoped directive stored in `injects` (scope = run:<run_id>).
+ * Never mutate story title/body.
  *
- * Deterministic trigger (config-driven):
+ * Deterministic trigger:
  * - config.workflow.genesis_planning:
  *    - "off"             => never attach directive
- *    - "first_story_only"=> attach only when story_key === "S-0001"
+ *    - "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 =
@@ -114,7 +131,7 @@ type GenesisPlanningMode = "off" | "first_story_only" | "always";
 function getGenesisPlanningMode(config: AstrocodeConfig): GenesisPlanningMode {
   const raw = (config as any)?.workflow?.genesis_planning;
   if (raw === "off" || raw === "first_story_only" || raw === "always") return raw;
-  if (raw != null) warn(`Invalid workflow.genesis_planning config: ${String(raw)}. Using default "first_story_only".`);
+  warn(`Invalid genesis_planning config: ${String(raw)}. Using default "first_story_only".`);
   return "first_story_only";
 }
 
@@ -126,6 +143,8 @@ function shouldAttachPlanningDirective(config: AstrocodeConfig, story: StoryRow)
 }
 
 function attachRunPlanningDirective(db: SqliteDb, runId: string, story: StoryRow, pipeline: StageKey[]) {
+  if (!tableExists(db, "injects")) return;
+
   const now = nowISO();
   const injectId = `inj_${runId}_genesis_plan`;
 
@@ -145,16 +164,9 @@ function attachRunPlanningDirective(db: SqliteDb, runId: string, story: StoryRow
     ``,
   ].join("\n");
 
-  let hash: string | null = null;
-  try {
-    hash = sha256Hex(body);
-  } catch {
-    // Hash is optional; directive must never be blocked by hashing.
-    hash = null;
-  }
+  const hash = sha256Hex(body);
 
   try {
-    // Do not clobber user edits. If it exists, we leave it.
     db.prepare(
       `
       INSERT OR IGNORE INTO injects (
@@ -169,173 +181,151 @@ function attachRunPlanningDirective(db: SqliteDb, runId: string, story: StoryRow
 
     db.prepare(
       "INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, NULL, ?, ?, ?)"
-    ).run(
-      newEventId(),
-      runId,
-      EVENT_TYPES.RUN_GENESIS_PLANNING_ATTACHED,
-      JSON.stringify({ story_key: story.story_key, inject_id: injectId }),
-      now
-    );
+    ).run(newEventId(), runId, EVENT_TYPES.RUN_GENESIS_PLANNING_ATTACHED, JSON.stringify({ story_key: story.story_key, inject_id: injectId }), now);
   } catch (e) {
-    // Helpful, never required for correctness.
     warn("Failed to attach genesis planning inject", { run_id: runId, story_key: story.story_key, err: e });
   }
 }
 
-function updateRepoStateLastEvent(db: SqliteDb, now: string, fields: { last_run_id?: string; last_story_key?: string }) {
-  // Contract: repo_state row exists. If not, fail deterministically (don’t “bootstrap” here).
-  const res = db
-    .prepare(
-      `
-      UPDATE repo_state
-      SET last_run_id = COALESCE(?, last_run_id),
-          last_story_key = COALESCE(?, last_story_key),
-          last_event_at = ?,
-          updated_at = ?
-      WHERE id = 1
-    `
-    )
-    .run(fields.last_run_id ?? null, fields.last_story_key ?? null, now, now);
-
-  if (!res || res.changes === 0) {
-    throw new Error("repo_state missing (id=1). Database not initialized; run init must be performed before workflow.");
-  }
-}
-
 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 run_id = newRunId();
-    const now = nowISO();
-    const pipeline = getPipelineFromConfig(config);
+  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})`);
 
-    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);
+  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);
+  });
 
-    if (shouldAttachPlanningDirective(config, story)) {
-      attachRunPlanningDirective(db, run_id, story, pipeline);
-    }
+  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);
 
-    updateRepoStateLastEvent(db, now, { last_run_id: run_id, last_story_key: storyKey });
+  if (shouldAttachPlanningDirective(config, story)) {
+    attachRunPlanningDirective(db, run_id, story, pipeline);
+  }
 
-    return { run_id };
-  });
+  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: SqliteDb,
   runId: string,
   stageKey: StageKey,
-  meta?: { subagent_type?: string; subagent_session_id?: string }
+  meta?: { subagent_type?: string; subagent_session_id?: string },
+  emit?: UiEmit
 ) {
-  return withTx(db, () => {
-    const now = nowISO();
+  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 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})`);
+  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(
-      "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 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("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(
+    "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);
 
-    updateRepoStateLastEvent(db, 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: SqliteDb, runId: string) {
-  return withTx(db, () => {
-    const now = nowISO();
+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})`);
 
-    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}`);
 
-    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 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(
-      "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(
-      "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);
 
-    updateRepoStateLastEvent(db, now, {});
-  });
+  // ✅ Explicit wiring point (requested): run closed success
+  emit?.({ kind: "run_completed", run_id: runId, story_key: run.story_key });
 }
 
-export function failRun(db: SqliteDb, runId: string, stageKey: StageKey, errorText: string) {
-  return withTx(db, () => {
-    const now = nowISO();
+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}`);
 
-    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);
 
-    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(
-      "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(
-      "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);
 
-    updateRepoStateLastEvent(db, 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: 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);
 
-    updateRepoStateLastEvent(db, now, {});
-  });
+  db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
 }