astrocode-workflow 0.1.59 → 0.2.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";
@@ -31,24 +32,20 @@ export function resolveAgentName(stageKey, config, agents, warnings) {
     // Validate that the agent actually exists in the registry
     if (agents && !agents[candidate]) {
         const warning = `Agent "${candidate}" not found in registry for stage "${stageKey}". Falling back to General.`;
-        if (warnings) {
+        if (warnings)
             warnings.push(warning);
-        }
-        else {
+        else
             console.warn(`[Astrocode] ${warning}`);
-        }
         candidate = "General";
     }
     // Final guard: ensure General exists, fallback to built-in "general" if not
     if (agents && !agents[candidate]) {
         const finalWarning = `Critical: General agent not found in registry. Falling back to built-in "general".`;
-        if (warnings) {
+        if (warnings)
             warnings.push(finalWarning);
-        }
-        else {
+        else
             console.warn(`[Astrocode] ${finalWarning}`);
-        }
-        return "general"; // built-in, guaranteed by OpenCode
+        return "general";
     }
     return candidate;
 }
@@ -84,9 +81,6 @@ function stageConstraints(stage, cfg) {
     }
     return common;
 }
-function agentNameForStage(stage, cfg) {
-    return cfg.agents.stage_agent_names[stage];
-}
 function buildDelegationPrompt(opts) {
     const { stageDirective, run_id, stage_key, stage_agent_name } = opts;
     const stageUpper = stage_key.toUpperCase();
@@ -108,10 +102,49 @@ function buildDelegationPrompt(opts) {
         ``,
         `Important: do NOT do any stage work yourself in orchestrator mode.`,
     ].join("\n").trim();
-    // Debug log the delegation prompt to troubleshoot agent output issues
     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 });
@@ -127,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") {
@@ -134,60 +170,24 @@ export function createAstroWorkflowProceedTool(opts) {
                     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 (config.ui.toasts.enabled && config.ui.toasts.show_run_started) {
-                        await toasts.show({ title: "Astrocode", message: `Run started (${run_id})`, variant: "success" });
-                    }
                     if (mode === "step")
                         break;
                     continue;
                 }
                 if (next.kind === "complete_run") {
-                    withTx(db, () => 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" });
-                    }
-                    // Inject continuation directive for workflow resumption
-                    if (sessionId) {
-                        const continueDirective = [
-                            `[SYSTEM DIRECTIVE: ASTROCODE — CONTINUE]`,
-                            ``,
-                            `Run ${next.run_id} completed successfully.`,
-                            ``,
-                            `The Clara Forms implementation run has finished all stages. The spec has been analyzed and decomposed into prioritized implementation stories.`,
-                            ``,
-                            `Next actions: Review the generated stories and approve the next one to continue development.`,
-                        ].join("\n");
-                        await injectChatPrompt({
-                            ctx,
-                            sessionId,
-                            text: continueDirective,
-                            agent: "Astro"
-                        });
-                        actions.push(`injected continuation directive for completed run ${next.run_id}`);
-                    }
-                    // Check for next approved story to start
-                    const nextStory = db.prepare("SELECT story_key, title FROM stories WHERE state = 'approved' ORDER BY priority DESC, created_at ASC LIMIT 1").get();
-                    if (nextStory && sessionId) {
-                        const nextDirective = [
-                            `[SYSTEM DIRECTIVE: ASTROCODE — START_NEXT_STORY]`,
-                            ``,
-                            `The previous run completed successfully. Start the next approved story.`,
-                            ``,
-                            `Next Story: ${nextStory.story_key} — ${nextStory.title}`,
-                            ``,
-                            `Action: Call astro_story_approve with story_key="${nextStory.story_key}" to start it, or select a different story.`,
-                        ].join("\n");
-                        await injectChatPrompt({
-                            ctx,
-                            sessionId,
-                            text: nextDirective,
-                            agent: "Astro"
-                        });
-                        actions.push(`injected directive to start next story ${nextStory.story_key}`);
-                    }
+                    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;
@@ -198,53 +198,37 @@ export function createAstroWorkflowProceedTool(opts) {
                         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);
-                    // Mark stage started + set subagent_type to the stage agent.
                     let agentName = resolveAgentName(next.stage_key, config, agents, warnings);
-                    // Validate agent availability with fallback chain
-                    const systemConfig = config;
-                    // Check both the system config agent map (if present) OR the local agents map passed to the tool
                     const agentExists = (name) => {
-                        // Check local agents map first (populated from src/index.ts)
-                        if (agents && agents[name]) {
-                            return true;
-                        }
-                        // Check system config agent map
-                        if (systemConfig.agent && systemConfig.agent[name]) {
+                        if (agents && agents[name])
                             return true;
-                        }
-                        // For known stage agents, assume they exist (they are system-provided subagents)
-                        const knownStageAgents = ["Frame", "Plan", "Spec", "Implement", "Review", "Verify", "Close"];
-                        if (knownStageAgents.includes(name)) {
+                        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 in config. Falling back to orchestrator.`);
-                        // First fallback: orchestrator
+                        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.`);
-                            // Final fallback: General (guaranteed to exist)
                             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 });
-                        // Log delegation observability
-                        if (config.debug?.telemetry?.enabled) {
-                            // eslint-disable-next-line no-console
-                            console.log(`[Astrocode:delegate] run_id=${active.run_id} stage=${next.stage_key} agent=${agentName} fallback=${agentName !== resolveAgentName(next.stage_key, config, agents) ? 'yes' : 'no'}`);
-                        }
+                        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}`,
                     });
-                    if (config.ui.toasts.enabled && config.ui.toasts.show_stage_started) {
-                        await toasts.show({ title: "Astrocode", message: `Stage started: ${next.stage_key}`, variant: "info" });
-                    }
-                    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,
@@ -262,22 +246,22 @@ export function createAstroWorkflowProceedTool(opts) {
                         stage_key: next.stage_key,
                         stage_agent_name: agentName,
                     });
-                    // Record in continuations as a stage directive (dedupe by hash)
+                    // 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" });
-                        // Inject continuation guidance
                         const continueMessage = [
                             `[SYSTEM DIRECTIVE: ASTROCODE — AWAIT_STAGE_COMPLETION]`,
                             ``,
-                            `Stage ${next.stage_key} delegated to ${agentName}.`,
+                            `Stage \`${next.stage_key}\` delegated to \`${agentName}\`.`,
                             ``,
-                            `When ${agentName} completes, call:`,
+                            `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.`,
@@ -290,13 +274,17 @@ export function createAstroWorkflowProceedTool(opts) {
                 }
                 if (next.kind === "await_stage_completion") {
                     actions.push(`await stage completion: ${next.stage_key}`);
-                    // Optionally nudge with a short directive
                     if (sessionId) {
-                        const context = buildContextSnapshot({ db, config, run_id: next.run_id, next_action: `complete stage ${next.stage_key}` });
+                        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.`,
+                            `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:`,
@@ -309,14 +297,31 @@ export function createAstroWorkflowProceedTool(opts) {
                     }
                     break;
                 }
-                if (next.kind === "failed") {
-                    actions.push(`failed: ${next.stage_key} — ${next.error_text}`);
-                    break;
-                }
-                // safety
                 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)`);
+            }
             // 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);

package/dist/ui/inject.d.ts

@@ -1,6 +1,12 @@
+/**
+ * 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;
+    sessionId?: string;
     text: string;
     agent?: string;
 }): Promise<void>;

package/dist/ui/inject.js

@@ -1,47 +1,95 @@
-let isInjecting = false;
-const injectionQueue = [];
-async function processQueue() {
-    if (isInjecting || injectionQueue.length === 0)
-        return;
-    isInjecting = true;
-    const opts = injectionQueue.shift();
-    if (!opts) {
-        isInjecting = false;
-        return;
+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 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}`;
+    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 runSessionQueue(sessionId) {
+    if (running.has(sessionId))
+        return;
+    running.add(sessionId);
     try {
-        const { ctx, sessionId, text, agent = "Astro" } = opts;
-        const prefixedText = `[${agent}]\n\n${text}`;
-        // Basic validation
-        if (!sessionId) {
-            console.warn("[Astrocode] Skipping injection: No sessionId provided");
-            return;
+        // 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();
+            }
+            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;
+                }
+                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);
+            }
         }
-        if (!ctx?.client?.session?.prompt) {
-            console.warn("[Astrocode] Skipping injection: API not available (ctx.client.session.prompt)");
-            return;
-        }
-        await ctx.client.session.prompt({
-            path: { id: sessionId },
-            body: {
-                parts: [{ type: "text", text: prefixedText }],
-                // Pass agent context for systems that support it
-                agent: agent,
-            },
-        });
-    }
-    catch (error) {
-        console.warn(`[Astrocode] Injection failed: ${error}`);
     }
     finally {
-        isInjecting = false;
-        // Process next item immediately
-        if (injectionQueue.length > 0) {
-            setImmediate(processQueue);
-        }
+        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(opts);
-    processQueue();
+    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);
+    });
 }

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

@@ -10,23 +10,39 @@ export declare const EVENT_TYPES: {
     readonly STAGE_STARTED: "stage.started";
     readonly WORKFLOW_PROCEED: "workflow.proceed";
 };
+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 = {
     kind: "idle";
@@ -64,7 +80,7 @@ export declare function createRunForStory(db: SqliteDb, config: AstrocodeConfig,
 export declare function startStage(db: SqliteDb, runId: string, stageKey: StageKey, meta?: {
     subagent_type?: string;
     subagent_session_id?: string;
-}): void;
-export declare function completeRun(db: SqliteDb, runId: string): void;
-export declare function failRun(db: SqliteDb, runId: string, stageKey: StageKey, errorText: string): 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;