astrocode-workflow 0.4.1 → 0.4.2

package/dist/src/astro/workflow-runner.d.ts

@@ -1,14 +1,10 @@
 /**
- * This is the only place you should hold the repo lock.
+ * Executes the workflow loop.
  * Everything that mutates the repo (tool calls, steps) runs inside this scope.
  *
  * Replace the internals with your actual astro/opencode driver loop.
  */
 export declare function runAstroWorkflow(opts: {
-    lockPath: string;
-    repoRoot: string;
-    sessionId: string;
-    owner?: string;
     proceedOneStep: () => Promise<{
         done: boolean;
     }>;

package/dist/src/astro/workflow-runner.js

@@ -1,25 +1,14 @@
 // src/astro/workflow-runner.ts
-import { acquireRepoLock } from "../state/repo-lock";
-import { workflowRepoLock } from "../state/workflow-repo-lock";
 /**
- * This is the only place you should hold the repo lock.
+ * Executes the workflow loop.
  * Everything that mutates the repo (tool calls, steps) runs inside this scope.
  *
  * Replace the internals with your actual astro/opencode driver loop.
  */
 export async function runAstroWorkflow(opts) {
-    await workflowRepoLock({ acquireRepoLock }, {
-        lockPath: opts.lockPath,
-        repoRoot: opts.repoRoot,
-        sessionId: opts.sessionId,
-        owner: opts.owner,
-        fn: async () => {
-            // ✅ Lock is held ONCE for the entire run. Tool calls can "rattle through".
-            while (true) {
-                const { done } = await opts.proceedOneStep();
-                if (done)
-                    return;
-            }
-        },
-    });
+    while (true) {
+        const { done } = await opts.proceedOneStep();
+        if (done)
+            return;
+    }
 }

package/dist/src/index.js

@@ -37,12 +37,6 @@ const Astrocode = async (ctx) => {
         throw new Error("Astrocode requires ctx.directory to be a string repo root.");
     }
     const repoRoot = ctx.directory;
-    // NOTE: Repo locking is handled at the workflow level via workflowRepoLock.
-    // The workflow tool correctly acquires and holds the lock for the entire workflow execution.
-    // Plugin-level locking is unnecessary and architecturally incorrect since:
-    // - The lock would be held for the entire session lifecycle (too long)
-    // - Individual tools are designed to be called within workflow context where lock is held
-    // - Workflow-level locking with refcounting prevents lock churn during tool execution
     // Always load config first - this provides defaults even in limited mode
     let pluginConfig;
     try {

package/dist/src/tools/health.js

@@ -19,36 +19,6 @@ export function createAstroHealthTool(opts) {
             lines.push(`- PID: ${process.pid || "unknown"}`);
             lines.push(`- Repo: ${repoRoot}`);
             lines.push(`- DB Path: ${fullDbPath}`);
-            // Lock status
-            const lockPath = `${repoRoot}/.astro/astro.lock`;
-            try {
-                if (fs.existsSync(lockPath)) {
-                    const lockContent = fs.readFileSync(lockPath, "utf8").trim();
-                    const parts = lockContent.split(" ");
-                    if (parts.length >= 2) {
-                        const pid = parseInt(parts[0]);
-                        const startedAt = parts[1];
-                        // Check if PID is still running
-                        try {
-                            process.kill(pid, 0); // Signal 0 just checks if process exists
-                            lines.push(`- Lock: HELD by PID ${pid} (started ${startedAt})`);
-                        }
-                        catch {
-                            lines.push(`- Lock: STALE (PID ${pid} not running, started ${startedAt})`);
-                            lines.push(`  → Run: rm "${lockPath}"`);
-                        }
-                    }
-                    else {
-                        lines.push(`- Lock: MALFORMED (${lockContent})`);
-                    }
-                }
-                else {
-                    lines.push(`- Lock: NONE (no lock file)`);
-                }
-            }
-            catch (e) {
-                lines.push(`- Lock: ERROR (${String(e)})`);
-            }
             // DB file status
             const dbExists = fs.existsSync(fullDbPath);
             const walExists = fs.existsSync(`${fullDbPath}-wal`);
@@ -109,7 +79,6 @@ export function createAstroHealthTool(opts) {
             lines.push(`## Status`);
             lines.push(`✅ DB accessible`);
             lines.push(`✅ Schema valid`);
-            lines.push(`✅ Lock file checked`);
             if (walExists || shmExists) {
                 lines.push(`⚠️ WAL/SHM files present - indicates unclean shutdown or active transaction`);
             }

package/dist/src/tools/index.js

@@ -11,7 +11,6 @@ import { createAstroRepairTool } from "./repair";
 import { createAstroHealthTool } from "./health";
 import { createAstroResetTool } from "./reset";
 import { createAstroMetricsTool } from "./metrics";
-import { createAstroLockStatusTool } from "./lock";
 export function createAstroTools(opts) {
     const { ctx, config, agents, runtime } = opts;
     const { db } = runtime;
@@ -23,7 +22,6 @@ export function createAstroTools(opts) {
     tools.astro_health = createAstroHealthTool({ ctx, config, db });
     tools.astro_reset = createAstroResetTool({ ctx, config, db });
     tools.astro_metrics = createAstroMetricsTool({ ctx, config });
-    tools.astro_lock_status = createAstroLockStatusTool({ ctx });
     // Recovery tool - available even in limited mode to allow DB initialization
     tools.astro_init = createAstroInitTool({ ctx, config, runtime });
     // Database-dependent tools
@@ -85,7 +83,6 @@ export function createAstroTools(opts) {
         ["_astro_health", "astro_health"],
         ["_astro_reset", "astro_reset"],
         ["_astro_metrics", "astro_metrics"],
-        ["_astro_lock_status", "astro_lock_status"],
     ];
     // Only add aliases for tools that exist
     for (const [alias, target] of aliases) {

package/dist/src/tools/repair.js

@@ -1,53 +1,20 @@
-import path from "node:path";
 import { tool } from "@opencode-ai/plugin/tool";
 import { withTx } from "../state/db";
 import { repairState, formatRepairReport } from "../workflow/repair";
 import { putArtifact } from "../workflow/artifacts";
 import { nowISO } from "../shared/time";
-import { getLockStatus, tryRemoveStaleLock } from "../state/repo-lock";
 export function createAstroRepairTool(opts) {
     const { ctx, config, db } = opts;
     return tool({
-        description: "Repair Astrocode invariants and recover from inconsistent DB state. Also checks and repairs lock files. Writes a repair report artifact.",
+        description: "Repair Astrocode invariants and recover from inconsistent DB state. Writes a repair report artifact.",
         args: {
             write_report_artifact: tool.schema.boolean().default(true),
-            repair_lock: tool.schema.boolean().default(true).describe("Attempt to remove stale/dead lock files"),
         },
-        execute: async ({ write_report_artifact, repair_lock }) => {
+        execute: async ({ write_report_artifact }) => {
             const repoRoot = ctx.directory;
-            const lockPath = path.join(repoRoot, ".astro", "astro.lock");
-            // First, check and repair lock if requested
-            const lockLines = [];
-            const lockStatus = getLockStatus(lockPath);
-            if (lockStatus.exists) {
-                lockLines.push("## Lock Status");
-                lockLines.push(`- Lock found: ${lockPath}`);
-                lockLines.push(`- PID: ${lockStatus.pid} (${lockStatus.pidAlive ? 'alive' : 'dead'})`);
-                lockLines.push(`- Age: ${lockStatus.ageMs ? Math.floor(lockStatus.ageMs / 1000) : '?'}s`);
-                lockLines.push(`- Status: ${lockStatus.isStale ? 'stale' : 'fresh'}`);
-                if (repair_lock) {
-                    const result = tryRemoveStaleLock(lockPath);
-                    if (result.removed) {
-                        lockLines.push(`- **Removed**: ${result.reason}`);
-                    }
-                    else {
-                        lockLines.push(`- **Not removed**: ${result.reason}`);
-                    }
-                }
-                else {
-                    if (!lockStatus.pidAlive || lockStatus.isStale) {
-                        lockLines.push(`- **Recommendation**: Run with repair_lock=true to remove this ${!lockStatus.pidAlive ? 'dead' : 'stale'} lock`);
-                    }
-                }
-                lockLines.push("");
-            }
-            // Then repair database state
+            // Repair database state
             const report = withTx(db, () => repairState(db, config));
-            const dbMd = formatRepairReport(report);
-            // Combine lock and DB repair
-            const fullMd = lockLines.length > 0
-                ? `# Astrocode Repair Report\n\n${lockLines.join("\n")}\n${dbMd.replace(/^# Astrocode repair report\n*/i, "")}`
-                : dbMd;
+            const fullMd = formatRepairReport(report);
             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: fullMd, meta: { kind: "repair" } });

package/dist/src/tools/workflow.js

@@ -1,6 +1,5 @@
 // src/tools/workflow.ts
 import { tool } from "@opencode-ai/plugin/tool";
-import path from "node:path";
 import { withTx } from "../state/db";
 import { buildContextSnapshot } from "../workflow/context";
 import { decideNextAction, createRunForStory, startStage, completeRun, failRun, getActiveRun, EVENT_TYPES, } from "../workflow/state-machine";
@@ -10,8 +9,6 @@ import { nowISO } from "../shared/time";
 import { newEventId } from "../state/ids";
 import { debug } from "../shared/log";
 import { createToastManager } from "../ui/toasts";
-import { acquireRepoLock } from "../state/repo-lock";
-import { workflowRepoLock } from "../state/workflow-repo-lock";
 // Agent name mapping for case-sensitive resolution
 export const STAGE_TO_AGENT_MAP = {
     frame: "Frame",
@@ -158,202 +155,191 @@ export function createAstroWorkflowProceedTool(opts) {
             max_steps: tool.schema.number().int().positive().default(config.workflow.default_max_steps),
         },
         execute: async ({ mode, max_steps }) => {
-            const repoRoot = ctx.directory;
-            const lockPath = path.join(repoRoot, ".astro", "astro.lock");
             const sessionId = ctx.sessionID;
-            return workflowRepoLock({ acquireRepoLock }, {
-                lockPath,
-                repoRoot,
-                sessionId,
-                owner: "astro_workflow_proceed",
-                advisory: true, // Advisory mode: warn instead of blocking on lock contention
-                fn: async () => {
-                    const steps = Math.min(max_steps, config.workflow.loop_max_steps_hard_cap);
-                    const actions = [];
-                    const warnings = [];
-                    const startedAt = nowISO();
-                    // Collect UI events emitted inside state-machine functions, then flush AFTER tx.
-                    const uiEvents = [];
-                    const emit = (e) => uiEvents.push(e);
-                    for (let i = 0; i < steps; i++) {
-                        const next = decideNextAction(db, config);
-                        if (next.kind === "idle") {
-                            actions.push("idle: no approved stories");
-                            break;
-                        }
-                        if (next.kind === "start_run") {
-                            // 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 (mode === "step")
-                                break;
-                            continue;
-                        }
-                        if (next.kind === "complete_run") {
-                            withTx(db, () => completeRun(db, next.run_id, emit));
-                            actions.push(`completed run ${next.run_id}`);
-                            if (mode === "step")
-                                break;
-                            continue;
-                        }
-                        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;
-                        }
-                        if (next.kind === "delegate_stage") {
-                            const active = getActiveRun(db);
-                            if (!active)
-                                throw new Error("Invariant: delegate_stage but no active run.");
-                            const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(active.run_id);
-                            const story = db.prepare("SELECT * FROM stories WHERE story_key=?").get(run.story_key);
-                            let agentName = resolveAgentName(next.stage_key, config, agents, warnings);
-                            const agentExists = (name) => {
-                                if (agents && agents[name])
-                                    return true;
-                                const knownStageAgents = ["Frame", "Plan", "Spec", "Implement", "Review", "Verify", "Close", "General", "Astro", "general"];
-                                if (knownStageAgents.includes(name))
-                                    return true;
-                                return false;
-                            };
+            const steps = Math.min(max_steps, config.workflow.loop_max_steps_hard_cap);
+            const actions = [];
+            const warnings = [];
+            const startedAt = nowISO();
+            // Collect UI events emitted inside state-machine functions, then flush AFTER tx.
+            const uiEvents = [];
+            const emit = (e) => uiEvents.push(e);
+            for (let i = 0; i < steps; i++) {
+                const next = decideNextAction(db, config);
+                if (next.kind === "idle") {
+                    actions.push("idle: no approved stories");
+                    break;
+                }
+                if (next.kind === "start_run") {
+                    // 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 (mode === "step")
+                        break;
+                    continue;
+                }
+                if (next.kind === "complete_run") {
+                    withTx(db, () => completeRun(db, next.run_id, emit));
+                    actions.push(`completed run ${next.run_id}`);
+                    if (mode === "step")
+                        break;
+                    continue;
+                }
+                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;
+                }
+                if (next.kind === "delegate_stage") {
+                    const active = getActiveRun(db);
+                    if (!active)
+                        throw new Error("Invariant: delegate_stage but no active run.");
+                    const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(active.run_id);
+                    const story = db.prepare("SELECT * FROM stories WHERE story_key=?").get(run.story_key);
+                    let agentName = resolveAgentName(next.stage_key, config, agents, warnings);
+                    const agentExists = (name) => {
+                        if (agents && agents[name])
+                            return true;
+                        const knownStageAgents = ["Frame", "Plan", "Spec", "Implement", "Review", "Verify", "Close", "General", "Astro", "general"];
+                        if (knownStageAgents.includes(name))
+                            return true;
+                        return false;
+                    };
+                    if (!agentExists(agentName)) {
+                        const originalAgent = agentName;
+                        console.warn(`[Astrocode] Agent ${agentName} not found. Falling back to orchestrator.`);
+                        agentName = config.agents?.orchestrator_name || "Astro";
+                        if (!agentExists(agentName)) {
+                            console.warn(`[Astrocode] Orchestrator ${agentName} not available. Falling back to General.`);
+                            agentName = "General";
                             if (!agentExists(agentName)) {
-                                const originalAgent = agentName;
-                                console.warn(`[Astrocode] Agent ${agentName} not found. Falling back to orchestrator.`);
-                                agentName = config.agents?.orchestrator_name || "Astro";
-                                if (!agentExists(agentName)) {
-                                    console.warn(`[Astrocode] Orchestrator ${agentName} not available. Falling back to General.`);
-                                    agentName = "General";
-                                    if (!agentExists(agentName)) {
-                                        throw new Error(`Critical: No agents available for delegation. Primary: ${originalAgent}, Orchestrator: ${config.agents?.orchestrator_name || "Astro"}, General: unavailable`);
-                                    }
-                                }
-                            }
-                            // NOTE: startStage owns its own tx (state-machine.ts).
-                            withTx(db, () => {
-                                startStage(db, active.run_id, next.stage_key, { subagent_type: agentName }, emit);
-                            });
-                            const context = buildContextSnapshot({
-                                db,
-                                config,
-                                run_id: active.run_id,
-                                next_action: `delegate stage ${next.stage_key}`,
-                            });
-                            const stageDirective = buildStageDirective({
-                                config,
-                                stage_key: next.stage_key,
-                                run_id: active.run_id,
-                                story_key: run.story_key,
-                                story_title: story?.title ?? "(missing)",
-                                stage_agent_name: agentName,
-                                stage_goal: stageGoal(next.stage_key, config),
-                                stage_constraints: stageConstraints(next.stage_key, config),
-                                context_snapshot_md: context,
-                            }).body;
-                            const delegatePrompt = buildDelegationPrompt({
-                                stageDirective,
-                                run_id: active.run_id,
-                                stage_key: next.stage_key,
-                                stage_agent_name: agentName,
-                            });
-                            // 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 (awaited)
-                            if (sessionId) {
-                                await injectChatPrompt({ ctx, sessionId, text: delegatePrompt, agent: "Astro" });
-                                const continueMessage = [
-                                    `[SYSTEM DIRECTIVE: ASTROCODE — AWAIT_STAGE_COMPLETION]`,
-                                    ``,
-                                    `Stage \`${next.stage_key}\` delegated to \`${agentName}\`.`,
-                                    ``,
-                                    `When \`${agentName}\` completes, call:`,
-                                    `astro_stage_complete(run_id="${active.run_id}", stage_key="${next.stage_key}", output_text="[paste subagent output here]")`,
-                                    ``,
-                                    `This advances the workflow.`,
-                                ].join("\n");
-                                await injectChatPrompt({ ctx, sessionId, text: continueMessage, agent: "Astro" });
+                                throw new Error(`Critical: No agents available for delegation. Primary: ${originalAgent}, Orchestrator: ${config.agents?.orchestrator_name || "Astro"}, General: unavailable`);
                             }
-                            actions.push(`delegated stage ${next.stage_key} via ${agentName}`);
-                            // Stop here; subagent needs to run.
-                            break;
                         }
-                        if (next.kind === "await_stage_completion") {
-                            actions.push(`await stage completion: ${next.stage_key}`);
-                            if (sessionId) {
-                                const context = buildContextSnapshot({
-                                    db,
-                                    config,
-                                    run_id: next.run_id,
-                                    next_action: `complete stage ${next.stage_key}`,
-                                });
-                                const prompt = [
-                                    `[SYSTEM DIRECTIVE: ASTROCODE — AWAIT_STAGE_OUTPUT]`,
-                                    ``,
-                                    `Run \`${next.run_id}\` is waiting for stage \`${next.stage_key}\` output.`,
-                                    `If you have the subagent output, call astro_stage_complete with output_text=the FULL output.`,
-                                    ``,
-                                    `Context snapshot:`,
-                                    context,
-                                ].join("\n").trim();
-                                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" });
-                            }
-                            break;
-                        }
-                        actions.push(`unhandled next action: ${next.kind}`);
-                        break;
                     }
-                    // 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?.sessionID) {
-                                await injectChatPrompt({
-                                    ctx,
-                                    sessionId: ctx.sessionID,
-                                    text: msg.chatText,
-                                    agent: "Astro",
-                                });
-                            }
-                        }
-                        actions.push(`ui: flushed ${uiEvents.length} event(s)`);
+                    // NOTE: startStage owns its own tx (state-machine.ts).
+                    withTx(db, () => {
+                        startStage(db, active.run_id, next.stage_key, { subagent_type: agentName }, emit);
+                    });
+                    const context = buildContextSnapshot({
+                        db,
+                        config,
+                        run_id: active.run_id,
+                        next_action: `delegate stage ${next.stage_key}`,
+                    });
+                    const stageDirective = buildStageDirective({
+                        config,
+                        stage_key: next.stage_key,
+                        run_id: active.run_id,
+                        story_key: run.story_key,
+                        story_title: story?.title ?? "(missing)",
+                        stage_agent_name: agentName,
+                        stage_goal: stageGoal(next.stage_key, config),
+                        stage_constraints: stageConstraints(next.stage_key, config),
+                        context_snapshot_md: context,
+                    }).body;
+                    const delegatePrompt = buildDelegationPrompt({
+                        stageDirective,
+                        run_id: active.run_id,
+                        stage_key: next.stage_key,
+                        stage_agent_name: agentName,
+                    });
+                    // 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);
                     }
-                    // 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 = [];
-                    lines.push(`# astro_workflow_proceed`);
-                    lines.push(`- mode: ${mode}`);
-                    lines.push(`- steps requested: ${max_steps} (cap=${steps})`);
-                    if (active)
-                        lines.push(`- active run: \`${active.run_id}\` (stage=${active.current_stage_key ?? "?"})`);
-                    lines.push(``, `## Actions`);
-                    for (const a of actions)
-                        lines.push(`- ${a}`);
-                    if (warnings.length > 0) {
-                        lines.push(``, `## Warnings`);
-                        for (const w of warnings)
-                            lines.push(`⚠️ ${w}`);
+                    // Visible injection so user can see state (awaited)
+                    if (sessionId) {
+                        await injectChatPrompt({ ctx, sessionId, text: delegatePrompt, agent: "Astro" });
+                        const continueMessage = [
+                            `[SYSTEM DIRECTIVE: ASTROCODE — AWAIT_STAGE_COMPLETION]`,
+                            ``,
+                            `Stage \`${next.stage_key}\` delegated to \`${agentName}\`.`,
+                            ``,
+                            `When \`${agentName}\` completes, call:`,
+                            `astro_stage_complete(run_id="${active.run_id}", stage_key="${next.stage_key}", output_text="[paste subagent output here]")`,
+                            ``,
+                            `This advances the workflow.`,
+                        ].join("\n");
+                        await injectChatPrompt({ ctx, sessionId, text: continueMessage, agent: "Astro" });
+                    }
+                    actions.push(`delegated stage ${next.stage_key} via ${agentName}`);
+                    // Stop here; subagent needs to run.
+                    break;
+                }
+                if (next.kind === "await_stage_completion") {
+                    actions.push(`await stage completion: ${next.stage_key}`);
+                    if (sessionId) {
+                        const context = buildContextSnapshot({
+                            db,
+                            config,
+                            run_id: next.run_id,
+                            next_action: `complete stage ${next.stage_key}`,
+                        });
+                        const prompt = [
+                            `[SYSTEM DIRECTIVE: ASTROCODE — AWAIT_STAGE_OUTPUT]`,
+                            ``,
+                            `Run \`${next.run_id}\` is waiting for stage \`${next.stage_key}\` output.`,
+                            `If you have the subagent output, call astro_stage_complete with output_text=the FULL output.`,
+                            ``,
+                            `Context snapshot:`,
+                            context,
+                        ].join("\n").trim();
+                        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" });
+                    }
+                    break;
+                }
+                actions.push(`unhandled next action: ${next.kind}`);
+                break;
+            }
+            // 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?.sessionID) {
+                        await injectChatPrompt({
+                            ctx,
+                            sessionId: ctx.sessionID,
+                            text: msg.chatText,
+                            agent: "Astro",
+                        });
                     }
-                    return lines.join("\n").trim();
-                },
-            });
+                }
+                actions.push(`ui: flushed ${uiEvents.length} event(s)`);
+            }
+            // 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 = [];
+            lines.push(`# astro_workflow_proceed`);
+            lines.push(`- mode: ${mode}`);
+            lines.push(`- steps requested: ${max_steps} (cap=${steps})`);
+            if (active)
+                lines.push(`- active run: \`${active.run_id}\` (stage=${active.current_stage_key ?? "?"})`);
+            lines.push(``, `## Actions`);
+            for (const a of actions)
+                lines.push(`- ${a}`);
+            if (warnings.length > 0) {
+                lines.push(``, `## Warnings`);
+                for (const w of warnings)
+                    lines.push(`⚠️ ${w}`);
+            }
+            return lines.join("\n").trim();
         },
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astrocode-workflow",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",