astrocode-workflow 0.3.0 → 0.3.2

package/src/tools/repair.ts

@@ -1,10 +1,12 @@
 import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
+import path from "node:path";
 import type { AstrocodeConfig } from "../config/schema";
 import type { SqliteDb } from "../state/db";
 import { withTx } from "../state/db";
 import { repairState, formatRepairReport } from "../workflow/repair";
 import { putArtifact } from "../workflow/artifacts";
 import { nowISO } from "../shared/time";
+import { withRepoLock } from "../state/repo-lock";
 
 export function createAstroRepairTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
   const { ctx, config, db } = opts;
@@ -16,16 +18,27 @@ export function createAstroRepairTool(opts: { ctx: any; config: AstrocodeConfig;
     },
     execute: async ({ write_report_artifact }) => {
       const repoRoot = ctx.directory as string;
-      const report = withTx(db, () => repairState(db, config));
-      const md = formatRepairReport(report);
+      const lockPath = path.join(repoRoot, ".astro", "astro.lock");
+      const sessionId = (ctx as any).sessionID as string | undefined;
 
-      if (write_report_artifact) {
-        const rel = `.astro/repair/repair_${nowISO().replace(/[:.]/g, "-")}.md`;
-        const a = putArtifact({ repoRoot, db, run_id: null, stage_key: null, type: "log", rel_path: rel, content: md, meta: { kind: "repair" } });
-        return md + `\n\nReport saved: ${rel} (artifact=${a.artifact_id})`;
-      }
+      return withRepoLock({
+        lockPath,
+        repoRoot,
+        sessionId,
+        owner: "astro_repair",
+        fn: async () => {
+          const report = withTx(db, () => repairState(db, config));
+          const md = formatRepairReport(report);
 
-      return md;
+          if (write_report_artifact) {
+            const rel = `.astro/repair/repair_${nowISO().replace(/[:.]/g, "-")}.md`;
+            const a = putArtifact({ repoRoot, db, run_id: null, stage_key: null, type: "log", rel_path: rel, content: md, meta: { kind: "repair" } });
+            return md + `\n\nReport saved: ${rel} (artifact=${a.artifact_id})`;
+          }
+
+          return md;
+        },
+      });
     },
   });
 }

package/src/tools/reset.ts

@@ -0,0 +1,100 @@
+// src/tools/reset.ts
+import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+import fs from "node:fs";
+import path from "node:path";
+
+export function createAstroResetTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
+  const { ctx, config, db } = opts;
+
+  return tool({
+    description: "Reset Astrocode database: safely delete all DB files and WAL/SHM after killing concurrent processes.",
+    args: {
+      confirm: tool.schema.string().default("").describe("Type 'RESET' to confirm destructive operation"),
+    },
+    execute: async ({ confirm }) => {
+      if (confirm !== "RESET") {
+        return [
+          "❌ Reset cancelled - confirmation required",
+          "",
+          "This operation will:",
+          "- Delete .astro/astro.db",
+          "- Delete .astro/astro.db-wal (if exists)",
+          "- Delete .astro/astro.db-shm (if exists)",
+          "- Lose all workflow data, stories, runs, artifacts",
+          "",
+          "To confirm: astro_reset(confirm=\"RESET\")",
+        ].join("\n");
+      }
+
+      const repoRoot = (ctx as any).directory || process.cwd();
+      const dbPath = config.db?.path || ".astro/astro.db";
+      const fullDbPath = path.resolve(repoRoot, dbPath);
+
+      const lines: string[] = [];
+      lines.push("🗑️ Astrocode Database Reset");
+      lines.push(`- Repo: ${repoRoot}`);
+      lines.push(`- Target: ${fullDbPath}`);
+
+      // Check for lock file
+      const lockPath = `${repoRoot}/.astro/astro.lock`;
+      if (fs.existsSync(lockPath)) {
+        try {
+          const lockContent = fs.readFileSync(lockPath, "utf8").trim();
+          const pid = parseInt(lockContent.split(" ")[0]);
+
+          lines.push(`- Lock file found for PID ${pid}`);
+
+          // Try to kill the process
+          try {
+            (process as any).kill(pid, 'SIGTERM');
+            lines.push(`- Sent SIGTERM to PID ${pid}, waiting 2s...`);
+            await new Promise(resolve => setTimeout(resolve, 2000));
+          } catch (e) {
+            lines.push(`- Could not kill PID ${pid}: ${String(e)}`);
+          }
+        } catch (e) {
+          lines.push(`- Error reading lock file: ${String(e)}`);
+        }
+      }
+
+      // Delete DB files
+      const filesToDelete = [
+        fullDbPath,
+        `${fullDbPath}-wal`,
+        `${fullDbPath}-shm`,
+        lockPath,
+      ];
+
+      let deletedCount = 0;
+      for (const filePath of filesToDelete) {
+        try {
+          if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+            lines.push(`- Deleted: ${path.relative(repoRoot, filePath)}`);
+            deletedCount++;
+          } else {
+            lines.push(`- Skipped: ${path.relative(repoRoot, filePath)} (not found)`);
+          }
+        } catch (e) {
+          lines.push(`- Failed to delete ${path.relative(repoRoot, filePath)}: ${String(e)}`);
+        }
+      }
+
+      lines.push(``);
+      if (deletedCount > 0) {
+        lines.push(`✅ Reset complete - ${deletedCount} files deleted`);
+        lines.push(``);
+        lines.push(`Next steps:`);
+        lines.push(`1. Run: astro_init`);
+        lines.push(`2. Run: astro_status`);
+        lines.push(`3. Import your stories and restart workflow`);
+      } else {
+        lines.push(`ℹ️ No files found to delete`);
+      }
+
+      return lines.join("\n");
+    },
+  });
+}

package/src/tools/stage.ts

@@ -13,6 +13,7 @@ import { getAstroPaths, ensureAstroDirs, toPosix } from "../shared/paths";
 import { failRun, getActiveRun, getStageRuns, startStage, completeRun } from "../workflow/state-machine";
 import { newEventId, newId } from "../state/ids";
 import { insertStory } from "../workflow/story-helpers";
+import { withRepoLock } from "../state/repo-lock";
 
 function nextStageKey(pipeline: StageKey[], current: StageKey): StageKey | null {
   const i = pipeline.indexOf(current);
@@ -128,6 +129,15 @@ export function createAstroStageCompleteTool(opts: { ctx: any; config: Astrocode
     },
     execute: async ({ run_id, stage_key, output_text, allow_new_stories, relation_reason }) => {
       const repoRoot = ctx.directory as string;
+      const lockPath = path.join(repoRoot, ".astro", "astro.lock");
+      const sessionId = (ctx as any).sessionID as string | undefined;
+
+      return withRepoLock({
+        lockPath,
+        repoRoot,
+        sessionId,
+        owner: "astro_stage_complete",
+        fn: async () => {
       const paths = getAstroPaths(repoRoot, config.db.path);
       ensureAstroDirs(paths);
 
@@ -391,6 +401,8 @@ Ensure JSON has required fields (stage_key, status) and valid syntax.`;
       lines.push(context);
 
       return lines.join("\n").trim();
+        },
+      });
     },
   });
 }

package/src/tools/status.ts

@@ -1,7 +1,9 @@
 import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
+import path from "node:path";
 import type { AstrocodeConfig } from "../config/schema";
 import type { SqliteDb } from "../state/db";
 import { decideNextAction, getActiveRun, getStageRuns, getStory } from "../workflow/state-machine";
+import { withRepoLock } from "../state/repo-lock";
 
 function statusIcon(status: string): string {
   switch (status) {
@@ -36,7 +38,7 @@ function stageIcon(status: string): string {
 }
 
 export function createAstroStatusTool(opts: { ctx: any; config: AstrocodeConfig; db?: SqliteDb | null }): ToolDefinition {
-  const { config, db } = opts;
+  const { ctx, config, db } = opts;
 
   return tool({
     description: "Show a compact Astrocode status dashboard: active run/stage, pipeline, story board counts, and next action.",
@@ -55,7 +57,17 @@ export function createAstroStatusTool(opts: { ctx: any; config: AstrocodeConfig;
         ].join("\n");
       }
 
-      try {
+      const repoRoot = ctx.directory as string;
+      const lockPath = path.join(repoRoot, ".astro", "astro.lock");
+      const sessionId = (ctx as any).sessionID as string | undefined;
+
+      return withRepoLock({
+        lockPath,
+        repoRoot,
+        sessionId,
+        owner: "astro_status",
+        fn: async () => {
+          try {
         const active = getActiveRun(db);
 
         const lines: string[] = [];
@@ -129,7 +141,9 @@ export function createAstroStatusTool(opts: { ctx: any; config: AstrocodeConfig;
           `⛔ Database error.`,
           `Error: ${msg}`,
         ].join("\n");
-      }
+          }
+        },
+      });
     },
   });
 }

package/src/tools/story.ts

@@ -1,4 +1,5 @@
 import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
+import path from "node:path";
 import type { AstrocodeConfig } from "../config/schema";
 import type { SqliteDb } from "../state/db";
 import { withTx } from "../state/db";
@@ -6,10 +7,11 @@ import { nowISO } from "../shared/time";
 import type { StoryState } from "../state/types";
 
 import { insertStory } from "../workflow/story-helpers";
+import { withRepoLock } from "../state/repo-lock";
 
 
 export function createAstroStoryQueueTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
-  const { db } = opts;
+  const { ctx, db } = opts;
 
   return tool({
     description: "Create a queued story (ticket) in Astrocode. Returns story_key.",
@@ -20,18 +22,30 @@ export function createAstroStoryQueueTool(opts: { ctx: any; config: AstrocodeCon
       priority: tool.schema.number().int().default(0),
     },
     execute: async ({ title, body_md, epic_key, priority }) => {
-      const story_key = withTx(db, () => {
-        const key = insertStory(db, { title, body_md, epic_key: epic_key ?? null, priority: priority ?? 0, state: 'queued' });
-        return key;
+      const repoRoot = ctx.directory as string;
+      const lockPath = path.join(repoRoot, ".astro", "astro.lock");
+      const sessionId = (ctx as any).sessionID as string | undefined;
+
+      return withRepoLock({
+        lockPath,
+        repoRoot,
+        sessionId,
+        owner: "astro_story_queue",
+        fn: async () => {
+          const story_key = withTx(db, () => {
+            const key = insertStory(db, { title, body_md, epic_key: epic_key ?? null, priority: priority ?? 0, state: 'queued' });
+            return key;
+          });
+
+          return `✅ Queued story ${story_key}: ${title}`;
+        },
       });
-
-      return `✅ Queued story ${story_key}: ${title}`;
     },
   });
 }
 
 export function createAstroStoryApproveTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
-  const { db } = opts;
+  const { ctx, db } = opts;
 
   return tool({
     description: "Approve a story so it becomes eligible to run.",
@@ -39,14 +53,26 @@ export function createAstroStoryApproveTool(opts: { ctx: any; config: AstrocodeC
       story_key: tool.schema.string().min(1),
     },
     execute: async ({ story_key }) => {
-      const now = nowISO();
-      const row = db.prepare("SELECT story_key, state, title FROM stories WHERE story_key=?").get(story_key) as any;
-      if (!row) throw new Error(`Story not found: ${story_key}`);
-
-      if (row.state === "approved") return `ℹ️ Story ${story_key} already approved.`;
-
-      db.prepare("UPDATE stories SET state='approved', approved_at=?, updated_at=? WHERE story_key=?").run(now, now, story_key);
-      return `✅ Approved story ${story_key}: ${row.title}`;
+      const repoRoot = ctx.directory as string;
+      const lockPath = path.join(repoRoot, ".astro", "astro.lock");
+      const sessionId = (ctx as any).sessionID as string | undefined;
+
+      return withRepoLock({
+        lockPath,
+        repoRoot,
+        sessionId,
+        owner: "astro_story_approve",
+        fn: async () => {
+          const now = nowISO();
+          const row = db.prepare("SELECT story_key, state, title FROM stories WHERE story_key=?").get(story_key) as any;
+          if (!row) throw new Error(`Story not found: ${story_key}`);
+
+          if (row.state === "approved") return `ℹ️ Story ${story_key} already approved.`;
+
+          db.prepare("UPDATE stories SET state='approved', approved_at=?, updated_at=? WHERE story_key=?").run(now, now, story_key);
+          return `✅ Approved story ${story_key}: ${row.title}`;
+        },
+      });
     },
   });
 }

package/src/tools/workflow.ts

@@ -1,17 +1,30 @@
 // src/tools/workflow.ts
 import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
+import path from "node:path";
 import type { AstrocodeConfig } from "../config/schema";
 import type { SqliteDb } from "../state/db";
+import { withTx } from "../state/db";
 import type { StageKey } from "../state/types";
+import type { UiEmitEvent } from "../workflow/state-machine";
 import { buildContextSnapshot } from "../workflow/context";
-import { decideNextAction, createRunForStory, startStage, completeRun, getActiveRun, EVENT_TYPES } from "../workflow/state-machine";
+import {
+  decideNextAction,
+  createRunForStory,
+  startStage,
+  completeRun,
+  failRun,
+  getActiveRun,
+  EVENT_TYPES,
+} from "../workflow/state-machine";
 import { buildStageDirective, directiveHash } from "../workflow/directives";
 import { injectChatPrompt } from "../ui/inject";
 import { nowISO } from "../shared/time";
 import { newEventId } from "../state/ids";
+import { withRepoLock } from "../state/repo-lock";
 import { debug } from "../shared/log";
 import { createToastManager } from "../ui/toasts";
 import type { AgentConfig } from "@opencode-ai/sdk";
+import { acquireRepoLock } from "../state/repo-lock";
 
 // Agent name mapping for case-sensitive resolution
 export const STAGE_TO_AGENT_MAP: Record<string, string> = {
@@ -118,10 +131,50 @@ function buildDelegationPrompt(opts: {
   ].join("\n").trim();
 
   debug(`Delegating stage ${stage_key} to agent ${stage_agent_name}`, { prompt_length: prompt.length });
-
   return prompt;
 }
 
+function buildUiMessage(e: UiEmitEvent): { title: string; message: string; variant: "info" | "success" | "error"; chatText: string } {
+  switch (e.kind) {
+    case "stage_started": {
+      const agent = e.agent_name ? ` (${e.agent_name})` : "";
+      const title = "Astrocode";
+      const message = `Stage started: ${e.stage_key}${agent}`;
+      const chatText = [
+        `[SYSTEM DIRECTIVE: ASTROCODE — STAGE_STARTED]`,
+        ``,
+        `Run: ${e.run_id}`,
+        `Stage: ${e.stage_key}${agent}`,
+      ].join("\n");
+      return { title, message, variant: "info", chatText };
+    }
+    case "run_completed": {
+      const title = "Astrocode";
+      const message = `Run completed: ${e.run_id}`;
+      const chatText = [
+        `[SYSTEM DIRECTIVE: ASTROCODE — RUN_COMPLETED]`,
+        ``,
+        `Run: ${e.run_id}`,
+        `Story: ${e.story_key}`,
+      ].join("\n");
+      return { title, message, variant: "success", chatText };
+    }
+    case "run_failed": {
+      const title = "Astrocode";
+      const message = `Run failed: ${e.run_id} (${e.stage_key})`;
+      const chatText = [
+        `[SYSTEM DIRECTIVE: ASTROCODE — RUN_FAILED]`,
+        ``,
+        `Run: ${e.run_id}`,
+        `Story: ${e.story_key}`,
+        `Stage: ${e.stage_key}`,
+        `Error: ${e.error_text}`,
+      ].join("\n");
+      return { title, message, variant: "error", chatText };
+    }
+  }
+}
+
 export function createAstroWorkflowProceedTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb; agents?: Record<string, AgentConfig> }): ToolDefinition {
   const { ctx, config, db, agents } = opts;
   const toasts = createToastManager({ ctx, throttleMs: config.ui.toasts.throttle_ms });
@@ -134,13 +187,26 @@ export function createAstroWorkflowProceedTool(opts: { ctx: any; config: Astroco
       max_steps: tool.schema.number().int().positive().default(config.workflow.default_max_steps),
     },
     execute: async ({ mode, max_steps }) => {
+      const repoRoot = (ctx as any).directory as string;
+      const lockPath = path.join(repoRoot, ".astro", "astro.lock");
       const sessionId = (ctx as any).sessionID as string | undefined;
-      const steps = Math.min(max_steps, config.workflow.loop_max_steps_hard_cap);
+
+      return withRepoLock({
+        lockPath,
+        repoRoot,
+        sessionId,
+        owner: "astro_workflow_proceed",
+        fn: async () => {
+        const steps = Math.min(max_steps, config.workflow.loop_max_steps_hard_cap);
 
       const actions: string[] = [];
       const warnings: string[] = [];
       const startedAt = nowISO();
 
+      // Collect UI events emitted inside state-machine functions, then flush AFTER tx.
+      const uiEvents: UiEmitEvent[] = [];
+      const emit = (e: UiEmitEvent) => uiEvents.push(e);
+
       for (let i = 0; i < steps; i++) {
         const next = decideNextAction(db, config);
 
@@ -150,60 +216,26 @@ export function createAstroWorkflowProceedTool(opts: { ctx: any; config: Astroco
         }
 
         if (next.kind === "start_run") {
-          // NOTE: createRunForStory owns its own tx (state-machine.ts).
-          const { run_id } = createRunForStory(db, config, next.story_key);
+          // SINGLE tx boundary: caller owns tx, state-machine is pure.
+          const { run_id } = withTx(db, () => createRunForStory(db, config, next.story_key));
           actions.push(`started run ${run_id} for story ${next.story_key}`);
 
-          if (config.ui.toasts.enabled && config.ui.toasts.show_run_started) {
-            await toasts.show({ title: "Astrocode", message: `Run started (${run_id})`, variant: "success" });
-          }
-
-          if (sessionId) {
-            await injectChatPrompt({
-              ctx,
-              sessionId,
-              agent: "Astro",
-              text: [
-                `[SYSTEM DIRECTIVE: ASTROCODE — RUN_STARTED]`,
-                ``,
-                `Run started: \`${run_id}\``,
-                `Story: \`${next.story_key}\``,
-                ``,
-                `Next: call **astro_workflow_proceed** again to delegate the first stage.`,
-              ].join("\n"),
-            });
-            actions.push(`injected run started message for ${run_id}`);
-          }
-
           if (mode === "step") break;
           continue;
         }
 
         if (next.kind === "complete_run") {
-          // NOTE: completeRun owns its own tx (state-machine.ts).
-          completeRun(db, next.run_id);
+          withTx(db, () => completeRun(db, next.run_id, emit));
           actions.push(`completed run ${next.run_id}`);
 
-          if (config.ui.toasts.enabled && config.ui.toasts.show_run_completed) {
-            await toasts.show({ title: "Astrocode", message: `Run completed (${next.run_id})`, variant: "success" });
-          }
+          if (mode === "step") break;
+          continue;
+        }
 
-          // ✅ explicit injection on completeRun (requested)
-          if (sessionId) {
-            await injectChatPrompt({
-              ctx,
-              sessionId,
-              agent: "Astro",
-              text: [
-                `[SYSTEM DIRECTIVE: ASTROCODE — RUN_COMPLETED]`,
-                ``,
-                `Run \`${next.run_id}\` completed.`,
-                ``,
-                `Next: call **astro_workflow_proceed** (mode=step) to start the next approved story (if any).`,
-              ].join("\n"),
-            });
-            actions.push(`injected run completed message for ${next.run_id}`);
-          }
+        if (next.kind === "failed") {
+          // Ensure DB state reflects failure in one tx; emit UI event.
+          withTx(db, () => failRun(db, next.run_id, next.stage_key, next.error_text, emit));
+          actions.push(`failed: ${next.stage_key} — ${next.error_text}`);
 
           if (mode === "step") break;
           continue;
@@ -241,30 +273,9 @@ export function createAstroWorkflowProceedTool(opts: { ctx: any; config: Astroco
           }
 
           // NOTE: startStage owns its own tx (state-machine.ts).
-          startStage(db, active.run_id, next.stage_key, { subagent_type: agentName });
-
-          actions.push(`stage started: ${next.stage_key}`);
-
-          if (config.ui.toasts.enabled && config.ui.toasts.show_stage_started) {
-            await toasts.show({ title: "Astrocode", message: `Stage started: ${next.stage_key}`, variant: "info" });
-          }
-
-          // ✅ explicit injection on startStage (requested)
-          if (sessionId) {
-            await injectChatPrompt({
-              ctx,
-              sessionId,
-              agent: "Astro",
-              text: [
-                `[SYSTEM DIRECTIVE: ASTROCODE — STAGE_STARTED]`,
-                ``,
-                `Run: \`${active.run_id}\``,
-                `Stage: \`${next.stage_key}\``,
-                `Delegated to: \`${agentName}\``,
-              ].join("\n"),
-            });
-            actions.push(`injected stage started message for ${next.stage_key}`);
-          }
+          withTx(db, () => {
+            startStage(db, active.run_id, next.stage_key, { subagent_type: agentName }, emit);
+          });
 
           const context = buildContextSnapshot({
             db,
@@ -292,20 +303,17 @@ export function createAstroWorkflowProceedTool(opts: { ctx: any; config: Astroco
             stage_agent_name: agentName,
           });
 
-          // Best-effort: continuations table may not exist on older DBs.
-          try {
-            const h = directiveHash(delegatePrompt);
-            const now = nowISO();
-            if (sessionId) {
-              db.prepare(
-                "INSERT INTO continuations (session_id, run_id, directive_hash, kind, reason, created_at) VALUES (?, ?, ?, 'stage', ?, ?)"
-              ).run(sessionId, active.run_id, h, `delegate ${next.stage_key}`, now);
-            }
-          } catch (e) {
-            warnings.push(`continuations insert failed (non-fatal): ${String(e)}`);
+          // Record continuation (best-effort; no tx wrapper needed but safe either way)
+          const h = directiveHash(delegatePrompt);
+          const now = nowISO();
+          if (sessionId) {
+            // This assumes continuations table exists in vNext schema.
+            db.prepare(
+              "INSERT INTO continuations (session_id, run_id, directive_hash, kind, reason, created_at) VALUES (?, ?, ?, 'stage', ?, ?)"
+            ).run(sessionId, active.run_id, h, `delegate ${next.stage_key}`, now);
           }
 
-          // Visible injection so user can see state
+          // Visible injection so user can see state (awaited)
           if (sessionId) {
             await injectChatPrompt({ ctx, sessionId, text: delegatePrompt, agent: "Astro" });
 
@@ -317,7 +325,7 @@ export function createAstroWorkflowProceedTool(opts: { ctx: any; config: Astroco
               `When \`${agentName}\` completes, call:`,
               `astro_stage_complete(run_id="${active.run_id}", stage_key="${next.stage_key}", output_text="[paste subagent output here]")`,
               ``,
-              `Then run **astro_workflow_proceed** again.`,
+              `This advances the workflow.`,
             ].join("\n");
 
             await injectChatPrompt({ ctx, sessionId, text: continueMessage, agent: "Astro" });
@@ -350,15 +358,11 @@ export function createAstroWorkflowProceedTool(opts: { ctx: any; config: Astroco
               context,
             ].join("\n").trim();
 
-            try {
-              const h = directiveHash(prompt);
-              const now = nowISO();
-              db.prepare(
-                "INSERT INTO continuations (session_id, run_id, directive_hash, kind, reason, created_at) VALUES (?, ?, ?, 'continue', ?, ?)"
-              ).run(sessionId, next.run_id, h, `await ${next.stage_key}`, now);
-            } catch (e) {
-              warnings.push(`continuations insert failed (non-fatal): ${String(e)}`);
-            }
+            const h = directiveHash(prompt);
+            const now = nowISO();
+            db.prepare(
+              "INSERT INTO continuations (session_id, run_id, directive_hash, kind, reason, created_at) VALUES (?, ?, ?, 'continue', ?, ?)"
+            ).run(sessionId, next.run_id, h, `await ${next.stage_key}`, now);
 
             await injectChatPrompt({ ctx, sessionId, text: prompt, agent: "Astro" });
           }
@@ -366,44 +370,40 @@ export function createAstroWorkflowProceedTool(opts: { ctx: any; config: Astroco
           break;
         }
 
-        if (next.kind === "failed") {
-          actions.push(`failed: ${next.stage_key} — ${next.error_text}`);
+        actions.push(`unhandled next action: ${(next as any).kind}`);
+        break;
+      }
 
-          if (sessionId) {
+      // Flush UI events (toast + prompt) AFTER state transitions
+      if (uiEvents.length > 0) {
+        for (const e of uiEvents) {
+          const msg = buildUiMessage(e);
+
+          if (config.ui.toasts.enabled) {
+            await toasts.show({
+              title: msg.title,
+              message: msg.message,
+              variant: msg.variant,
+            });
+          }
+
+          if ((ctx as any)?.sessionID) {
             await injectChatPrompt({
               ctx,
-              sessionId,
+              sessionId: (ctx as any).sessionID,
+              text: msg.chatText,
               agent: "Astro",
-              text: [
-                `[SYSTEM DIRECTIVE: ASTROCODE — RUN_FAILED]`,
-                ``,
-                `Run \`${next.run_id}\` failed at stage \`${next.stage_key}\`.`,
-                `Error: ${next.error_text}`,
-              ].join("\n"),
             });
-            actions.push(`injected run failed message for ${next.run_id}`);
           }
-
-          break;
         }
 
-        actions.push(`unhandled next action: ${(next as any).kind}`);
-        break;
+        actions.push(`ui: flushed ${uiEvents.length} event(s)`);
       }
 
-      // Housekeeping event (best-effort)
-      try {
-        db.prepare(
-          "INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, NULL, NULL, ?, ?, ?)"
-        ).run(
-          newEventId(),
-          EVENT_TYPES.WORKFLOW_PROCEED,
-          JSON.stringify({ started_at: startedAt, mode, max_steps: steps, actions }),
-          nowISO()
-        );
-      } catch (e) {
-        warnings.push(`workflow.proceed event insert failed (non-fatal): ${String(e)}`);
-      }
+      // Housekeeping event
+      db.prepare(
+        "INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, NULL, NULL, ?, ?, ?)"
+      ).run(newEventId(), EVENT_TYPES.WORKFLOW_PROCEED, JSON.stringify({ started_at: startedAt, mode, max_steps: steps, actions }), nowISO());
 
       const active = getActiveRun(db);
       const lines: string[] = [];
@@ -420,6 +420,8 @@ export function createAstroWorkflowProceedTool(opts: { ctx: any; config: Astroco
       }
 
       return lines.join("\n").trim();
+        },
+      });
     },
   });
 }