astrocode-workflow 0.3.0 → 0.3.1

package/dist/tools/workflow.js

@@ -1,7 +1,8 @@
 // src/tools/workflow.ts
 import { tool } from "@opencode-ai/plugin/tool";
+import { withTx } from "../state/db";
 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";
@@ -104,6 +105,46 @@ function buildDelegationPrompt(opts) {
     debug(`Delegating stage ${stage_key} to agent ${stage_agent_name}`, { prompt_length: prompt.length });
     return prompt;
 }
+function buildUiMessage(e) {
+    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) {
     const { ctx, config, db, agents } = opts;
     const toasts = createToastManager({ ctx, throttleMs: config.ui.toasts.throttle_ms });
@@ -119,6 +160,9 @@ export function createAstroWorkflowProceedTool(opts) {
             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") {
@@ -126,55 +170,24 @@ export function createAstroWorkflowProceedTool(opts) {
                     break;
                 }
                 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" });
-                    }
-                    // ✅ 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 (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;
@@ -207,27 +220,9 @@ export function createAstroWorkflowProceedTool(opts) {
                         }
                     }
                     // 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,
                         config,
@@ -251,18 +246,14 @@ export function createAstroWorkflowProceedTool(opts) {
                         stage_key: next.stage_key,
                         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" });
                         const continueMessage = [
@@ -273,7 +264,7 @@ export function createAstroWorkflowProceedTool(opts) {
                             `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" });
                     }
@@ -299,46 +290,40 @@ export function createAstroWorkflowProceedTool(opts) {
                             `Context snapshot:`,
                             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" });
                     }
                     break;
                 }
-                if (next.kind === "failed") {
-                    actions.push(`failed: ${next.stage_key} — ${next.error_text}`);
-                    if (sessionId) {
+                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,
+                            sessionId: ctx.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.kind}`);
-                break;
-            }
-            // 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)}`);
+                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`);

package/dist/ui/inject.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Inject a visible prompt into the conversation.
+ * - Deterministic ordering per session
+ * - Correct SDK binding (prevents `this._client` undefined)
+ * - Awaitable: resolves when delivered, rejects after max retries
+ */
 export declare function injectChatPrompt(opts: {
     ctx: any;
     sessionId?: string;

package/dist/ui/inject.js

@@ -1,88 +1,95 @@
-// src/ui/inject.ts
-let isInjecting = false;
-const injectionQueue = [];
+const MAX_ATTEMPTS = 4;
+const RETRY_DELAYS_MS = [250, 500, 1000, 2000]; // attempt 1..4
+// Per-session queues so one stuck session doesn't block others
+const queues = new Map();
+const running = new Set();
 function sleep(ms) {
     return new Promise((r) => setTimeout(r, ms));
 }
-function resolveSessionId(ctx, sessionId) {
-    if (sessionId)
-        return sessionId;
-    const direct = ctx?.sessionID ?? ctx?.sessionId ?? ctx?.session?.id;
-    if (typeof direct === "string" && direct.length > 0)
-        return direct;
-    return null;
-}
-async function tryInjectOnce(opts) {
-    const { ctx, sessionId, text, agent } = opts;
-    // Prefer explicit chat prompt API
-    const promptApi = ctx?.client?.session?.prompt;
-    if (!promptApi) {
+function getPromptInvoker(ctx) {
+    const session = ctx?.client?.session;
+    const prompt = session?.prompt;
+    if (!session || typeof prompt !== "function") {
         throw new Error("API not available (ctx.client.session.prompt)");
     }
+    return { session, prompt };
+}
+async function tryInjectOnce(item) {
+    const { ctx, sessionId, text, agent = "Astro" } = item;
     const prefixedText = `[${agent}]\n\n${text}`;
-    // Some hosts reject unknown fields; keep body minimal and stable.
-    await promptApi({
+    const { session, prompt } = getPromptInvoker(ctx);
+    // IMPORTANT: force correct `this` binding
+    await prompt.call(session, {
         path: { id: sessionId },
         body: {
             parts: [{ type: "text", text: prefixedText }],
+            agent,
         },
     });
 }
-async function processQueue() {
-    if (isInjecting)
+async function runSessionQueue(sessionId) {
+    if (running.has(sessionId))
         return;
-    if (injectionQueue.length === 0)
-        return;
-    isInjecting = true;
+    running.add(sessionId);
     try {
-        while (injectionQueue.length > 0) {
-            const item = injectionQueue.shift();
-            if (!item)
-                continue;
-            const { ctx, text, agent = "Astro" } = item;
-            const sessionId = resolveSessionId(ctx, item.sessionId);
-            if (!sessionId) {
-                // Drop on floor: we cannot recover without a session id.
-                // Keep draining the queue so we don't stall.
-                // eslint-disable-next-line no-console
-                console.warn("[Astrocode] Injection skipped: no sessionId");
-                continue;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const q = queues.get(sessionId);
+            if (!q || q.length === 0)
+                break;
+            const item = q.shift();
+            try {
+                await tryInjectOnce(item);
+                item.resolve();
             }
-            const maxAttempts = item.retry?.maxAttempts ?? 4;
-            const baseDelayMs = item.retry?.baseDelayMs ?? 250;
-            let lastErr = null;
-            for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-                try {
-                    await tryInjectOnce({ ctx, sessionId, text, agent });
-                    lastErr = null;
-                    break;
-                }
-                catch (e) {
-                    lastErr = e;
-                    const delay = baseDelayMs * Math.pow(2, attempt - 1); // 250, 500, 1000, 2000
-                    // eslint-disable-next-line no-console
-                    console.warn(`[Astrocode] Injection attempt ${attempt}/${maxAttempts} failed: ${String(e)}; retrying in ${delay}ms`);
-                    await sleep(delay);
+            catch (err) {
+                item.attempts += 1;
+                const msg = err instanceof Error ? err.message : String(err);
+                const delay = RETRY_DELAYS_MS[Math.min(item.attempts - 1, RETRY_DELAYS_MS.length - 1)] ?? 2000;
+                if (item.attempts >= MAX_ATTEMPTS) {
+                    console.warn(`[Astrocode] Injection failed permanently after ${item.attempts} attempts: ${msg}`);
+                    item.reject(err);
+                    continue;
                 }
-            }
-            if (lastErr) {
-                // eslint-disable-next-line no-console
-                console.warn(`[Astrocode] Injection failed permanently after ${maxAttempts} attempts: ${String(lastErr)}`);
+                console.warn(`[Astrocode] Injection attempt ${item.attempts}/${MAX_ATTEMPTS} failed: ${msg}; retrying in ${delay}ms`);
+                await sleep(delay);
+                // Requeue at front to preserve order (and avoid starving later messages)
+                const q2 = queues.get(sessionId) ?? [];
+                q2.unshift(item);
+                queues.set(sessionId, q2);
             }
         }
     }
     finally {
-        isInjecting = false;
+        running.delete(sessionId);
     }
 }
+/**
+ * Inject a visible prompt into the conversation.
+ * - Deterministic ordering per session
+ * - Correct SDK binding (prevents `this._client` undefined)
+ * - Awaitable: resolves when delivered, rejects after max retries
+ */
 export async function injectChatPrompt(opts) {
-    injectionQueue.push({
-        ctx: opts.ctx,
-        sessionId: opts.sessionId,
-        text: opts.text,
-        agent: opts.agent ?? "Astro",
-        retry: { maxAttempts: 4, baseDelayMs: 250 },
+    const sessionId = opts.sessionId ?? opts.ctx?.sessionID;
+    if (!sessionId) {
+        console.warn("[Astrocode] Skipping injection: No sessionId provided");
+        return;
+    }
+    return new Promise((resolve, reject) => {
+        const item = {
+            ctx: opts.ctx,
+            sessionId,
+            text: opts.text,
+            agent: opts.agent,
+            attempts: 0,
+            resolve,
+            reject,
+        };
+        const q = queues.get(sessionId) ?? [];
+        q.push(item);
+        queues.set(sessionId, q);
+        // Fire worker (don't await here; caller awaits the returned Promise)
+        void runSessionQueue(sessionId);
     });
-    // Fire-and-forget; queue drain is serialized by isInjecting.
-    void processQueue();
 }

package/dist/workflow/state-machine.d.ts

@@ -1,7 +1,6 @@
 import type { AstrocodeConfig } from "../config/schema";
 import type { SqliteDb } from "../state/db";
 import type { RunRow, StageKey, StageRunRow, StoryRow } from "../state/types";
-import type { ToastOptions } from "../ui/toasts";
 export declare const EVENT_TYPES: {
     readonly RUN_STARTED: "run.started";
     readonly RUN_COMPLETED: "run.completed";
@@ -11,28 +10,39 @@ export declare const EVENT_TYPES: {
     readonly STAGE_STARTED: "stage.started";
     readonly WORKFLOW_PROCEED: "workflow.proceed";
 };
-/**
- * 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;
-    toast?: (t: ToastOptions) => Promise<void>;
+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";
@@ -67,20 +77,10 @@ export declare function decideNextAction(db: SqliteDb, config: AstrocodeConfig):
 export declare function createRunForStory(db: SqliteDb, config: AstrocodeConfig, storyKey: string): {
     run_id: string;
 };
-/**
- * STAGE MOVEMENT (START) — now async so UI injection is deterministic.
- */
 export declare function startStage(db: SqliteDb, runId: string, stageKey: StageKey, meta?: {
     subagent_type?: string;
     subagent_session_id?: string;
-    ui?: WorkflowUi;
-}): Promise<void>;
-/**
- * STAGE CLOSED (RUN COMPLETED) — now async so UI injection is deterministic.
- */
-export declare function completeRun(db: SqliteDb, runId: string, ui?: WorkflowUi): Promise<void>;
-/**
- * STAGE CLOSED (RUN FAILED) — now async so UI injection is deterministic.
- */
-export declare function failRun(db: SqliteDb, runId: string, stageKey: StageKey, errorText: string, ui?: WorkflowUi): Promise<void>;
+}, emit?: UiEmit): void;
+export declare function completeRun(db: SqliteDb, runId: string, emit?: UiEmit): void;
+export declare function failRun(db: SqliteDb, runId: string, stageKey: StageKey, errorText: string, emit?: UiEmit): void;
 export declare function abortRun(db: SqliteDb, runId: string, reason: string): void;