astrocode-workflow 0.2.0 → 0.3.0

package/dist/state/db.d.ts

@@ -4,7 +4,7 @@ export declare function openSqlite(dbPath: string, opts?: {
     busyTimeoutMs?: number;
 }): SqliteDb;
 export declare function configurePragmas(db: SqliteDb, pragmas: Record<string, any>): void;
-/** BEGIN IMMEDIATE transaction helper. */
+/** BEGIN IMMEDIATE transaction helper (re-entrant). */
 export declare function withTx<T>(db: SqliteDb, fn: () => T, opts?: {
     require?: boolean;
 }): T;

package/dist/state/db.js

@@ -46,7 +46,30 @@ export function configurePragmas(db, pragmas) {
     if (pragmas.temp_store)
         db.pragma(`temp_store = ${pragmas.temp_store}`);
 }
-/** BEGIN IMMEDIATE transaction helper. */
+/**
+ * Re-entrant transaction helper.
+ *
+ * SQLite rejects BEGIN inside BEGIN. We use:
+ * - depth=0: BEGIN IMMEDIATE ... COMMIT/ROLLBACK
+ * - depth>0: SAVEPOINT sp_n ... RELEASE / ROLLBACK TO + RELEASE
+ *
+ * This allows callers to safely nest withTx across layers (tools -> workflow -> state machine)
+ * without "cannot start a transaction within a transaction".
+ */
+const TX_DEPTH = new WeakMap();
+function getDepth(db) {
+    return TX_DEPTH.get(db) ?? 0;
+}
+function setDepth(db, depth) {
+    if (depth <= 0)
+        TX_DEPTH.delete(db);
+    else
+        TX_DEPTH.set(db, depth);
+}
+function savepointName(depth) {
+    return `sp_${depth}`;
+}
+/** BEGIN IMMEDIATE transaction helper (re-entrant). */
 export function withTx(db, fn, opts) {
     const adapter = createDatabaseAdapter();
     const available = adapter.isAvailable();
@@ -55,21 +78,56 @@ export function withTx(db, fn, opts) {
             throw new Error("Database adapter unavailable; transaction required.");
         return fn();
     }
-    db.exec("BEGIN IMMEDIATE");
+    const depth = getDepth(db);
+    if (depth === 0) {
+        db.exec("BEGIN IMMEDIATE");
+        setDepth(db, 1);
+        try {
+            const out = fn();
+            db.exec("COMMIT");
+            return out;
+        }
+        catch (e) {
+            try {
+                db.exec("ROLLBACK");
+            }
+            catch {
+                // ignore
+            }
+            throw e;
+        }
+        finally {
+            setDepth(db, 0);
+        }
+    }
+    // Nested: use SAVEPOINT
+    const nextDepth = depth + 1;
+    const sp = savepointName(nextDepth);
+    db.exec(`SAVEPOINT ${sp}`);
+    setDepth(db, nextDepth);
     try {
         const out = fn();
-        db.exec("COMMIT");
+        db.exec(`RELEASE SAVEPOINT ${sp}`);
         return out;
     }
     catch (e) {
         try {
-            db.exec("ROLLBACK");
+            db.exec(`ROLLBACK TO SAVEPOINT ${sp}`);
+        }
+        catch {
+            // ignore
+        }
+        try {
+            db.exec(`RELEASE SAVEPOINT ${sp}`);
         }
         catch {
             // ignore
         }
         throw e;
     }
+    finally {
+        setDepth(db, depth);
+    }
 }
 export function getSchemaVersion(db) {
     try {

package/dist/tools/workflow.d.ts

@@ -2,9 +2,9 @@ import { type ToolDefinition } from "@opencode-ai/plugin/tool";
 import type { AstrocodeConfig } from "../config/schema";
 import type { SqliteDb } from "../state/db";
 import type { StageKey } from "../state/types";
+import type { AgentConfig } from "@opencode-ai/sdk";
 export declare const STAGE_TO_AGENT_MAP: Record<string, string>;
 export declare function resolveAgentName(stageKey: StageKey, config: AstrocodeConfig, agents?: any, warnings?: string[]): string;
-import { AgentConfig } from "@opencode-ai/sdk";
 export declare function createAstroWorkflowProceedTool(opts: {
     ctx: any;
     config: AstrocodeConfig;

package/dist/tools/workflow.js

@@ -1,5 +1,5 @@
+// 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 { buildStageDirective, directiveHash } from "../workflow/directives";
@@ -31,24 +31,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 +80,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,7 +101,6 @@ 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;
 }
@@ -134,59 +126,54 @@ export function createAstroWorkflowProceedTool(opts) {
                     break;
                 }
                 if (next.kind === "start_run") {
-                    const { run_id } = withTx(db, () => createRunForStory(db, config, next.story_key));
+                    // NOTE: createRunForStory owns its own tx (state-machine.ts).
+                    const { run_id } = 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") {
-                    withTx(db, () => completeRun(db, next.run_id));
+                    // NOTE: completeRun owns its own tx (state-machine.ts).
+                    completeRun(db, next.run_id);
                     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
+                    // ✅ explicit injection on completeRun (requested)
                     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"
+                            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 directive to start next story ${nextStory.story_key}`);
+                        actions.push(`injected run completed message for ${next.run_id}`);
                     }
                     if (mode === "step")
                         break;
@@ -198,53 +185,55 @@ 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]) {
+                        if (agents && agents[name])
                             return true;
-                        }
-                        // Check system config agent map
-                        if (systemConfig.agent && systemConfig.agent[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`);
                             }
                         }
                     }
-                    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'}`);
-                        }
-                    });
+                    // 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" });
                     }
-                    const context = buildContextSnapshot({ db, config, run_id: active.run_id, next_action: `delegate stage ${next.stage_key}` });
+                    // ✅ 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}`);
+                    }
+                    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,25 +251,29 @@ export function createAstroWorkflowProceedTool(opts) {
                         stage_key: next.stage_key,
                         stage_agent_name: agentName,
                     });
-                    // Record in continuations as a stage directive (dedupe by hash)
-                    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);
+                    // 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)}`);
                     }
                     // Visible injection so user can see state
                     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.`,
+                            `Then run **astro_workflow_proceed** again.`,
                         ].join("\n");
                         await injectChatPrompt({ ctx, sessionId, text: continueMessage, agent: "Astro" });
                     }
@@ -290,35 +283,62 @@ 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:`,
                             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);
+                        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)}`);
+                        }
                         await injectChatPrompt({ ctx, sessionId, text: prompt, agent: "Astro" });
                     }
                     break;
                 }
                 if (next.kind === "failed") {
                     actions.push(`failed: ${next.stage_key} — ${next.error_text}`);
+                    if (sessionId) {
+                        await injectChatPrompt({
+                            ctx,
+                            sessionId,
+                            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;
                 }
-                // safety
                 actions.push(`unhandled next action: ${next.kind}`);
                 break;
             }
-            // 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());
+            // 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)}`);
+            }
             const active = getActiveRun(db);
             const lines = [];
             lines.push(`# astro_workflow_proceed`);

package/dist/ui/inject.d.ts

@@ -1,20 +1,6 @@
-type QueueItem = {
+export declare function injectChatPrompt(opts: {
     ctx: any;
-    sessionId: string;
+    sessionId?: string;
     text: string;
     agent?: string;
-};
-/**
- * Enqueue an injection and ensure the worker is running.
- * Does NOT wait for delivery — use `flushChatPrompts()` to wait.
- */
-export declare function enqueueChatPrompt(opts: QueueItem): void;
-/**
- * Wait until all queued injections have been processed (sent or exhausted retries).
- */
-export declare function flushChatPrompts(): Promise<void>;
-/**
- * Deterministic helper: enqueue + flush (recommended for stage boundaries).
- */
-export declare function injectChatPrompt(opts: QueueItem): Promise<void>;
-export {};
+}): Promise<void>;

package/dist/ui/inject.js

@@ -1,118 +1,88 @@
 // src/ui/inject.ts
-//
-// Deterministic chat injection:
-// - Always enqueue
-// - Process sequentially (per-process single worker)
-// - Retries with backoff
-// - flush() lets callers wait until injections are actually sent
-//
-// IMPORTANT: Callers who need reliability must `await injectChatPrompt(...)`
-// or `await flushChatPrompts()` after enqueueing.
+let isInjecting = false;
 const injectionQueue = [];
-let workerRunning = false;
-// Used to let callers await "queue drained"
-let drainWaiters = [];
 function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise((r) => setTimeout(r, ms));
 }
-function resolveDrainWaitersIfIdle() {
-    if (workerRunning)
-        return;
-    if (injectionQueue.length !== 0)
-        return;
-    const waiters = drainWaiters;
-    drainWaiters = [];
-    for (const w of waiters)
-        w();
-}
-function getPromptApi(ctx) {
-    const fn = ctx?.client?.session?.prompt;
-    return typeof fn === "function" ? fn.bind(ctx.client.session) : null;
+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 sendWithRetries(opts) {
-    const { ctx, sessionId, text } = opts;
-    const agent = opts.agent ?? "Astro";
-    const prefixedText = `[${agent}]\n\n${text}`;
-    if (!sessionId) {
-        console.warn("[Astrocode] Injection skipped: missing sessionId");
-        return;
-    }
-    const prompt = getPromptApi(ctx);
-    if (!prompt) {
-        console.warn("[Astrocode] Injection skipped: ctx.client.session.prompt unavailable");
-        return;
-    }
-    const maxAttempts = 3;
-    let attempt = 0;
-    while (attempt < maxAttempts) {
-        attempt += 1;
-        try {
-            await prompt({
-                path: { id: sessionId },
-                body: {
-                    parts: [{ type: "text", text: prefixedText }],
-                    agent,
-                },
-            });
-            return;
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            const isLast = attempt >= maxAttempts;
-            if (isLast) {
-                console.warn(`[Astrocode] Injection failed (final): ${msg}`);
-                return;
-            }
-            // Exponential backoff + jitter
-            const base = 150 * Math.pow(2, attempt - 1); // 150, 300, 600
-            const jitter = Math.floor(Math.random() * 120);
-            await sleep(base + jitter);
-        }
+async function tryInjectOnce(opts) {
+    const { ctx, sessionId, text, agent } = opts;
+    // Prefer explicit chat prompt API
+    const promptApi = ctx?.client?.session?.prompt;
+    if (!promptApi) {
+        throw new Error("API not available (ctx.client.session.prompt)");
     }
+    const prefixedText = `[${agent}]\n\n${text}`;
+    // Some hosts reject unknown fields; keep body minimal and stable.
+    await promptApi({
+        path: { id: sessionId },
+        body: {
+            parts: [{ type: "text", text: prefixedText }],
+        },
+    });
 }
-async function runWorkerLoop() {
-    if (workerRunning)
+async function processQueue() {
+    if (isInjecting)
+        return;
+    if (injectionQueue.length === 0)
         return;
-    workerRunning = true;
+    isInjecting = true;
     try {
-        // Drain sequentially to preserve ordering
         while (injectionQueue.length > 0) {
             const item = injectionQueue.shift();
             if (!item)
                 continue;
-            await sendWithRetries(item);
+            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;
+            }
+            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);
+                }
+            }
+            if (lastErr) {
+                // eslint-disable-next-line no-console
+                console.warn(`[Astrocode] Injection failed permanently after ${maxAttempts} attempts: ${String(lastErr)}`);
+            }
         }
     }
     finally {
-        workerRunning = false;
-        resolveDrainWaitersIfIdle();
+        isInjecting = false;
     }
 }
-/**
- * Enqueue an injection and ensure the worker is running.
- * Does NOT wait for delivery — use `flushChatPrompts()` to wait.
- */
-export function enqueueChatPrompt(opts) {
-    injectionQueue.push(opts);
-    // Kick worker
-    void runWorkerLoop();
-}
-/**
- * Wait until all queued injections have been processed (sent or exhausted retries).
- */
-export function flushChatPrompts() {
-    if (!workerRunning && injectionQueue.length === 0)
-        return Promise.resolve();
-    return new Promise((resolve) => {
-        drainWaiters.push(resolve);
-        // Ensure worker is running (in case someone enqueued without kick)
-        void runWorkerLoop();
-    });
-}
-/**
- * Deterministic helper: enqueue + flush (recommended for stage boundaries).
- */
 export async function injectChatPrompt(opts) {
-    enqueueChatPrompt(opts);
-    await flushChatPrompts();
+    injectionQueue.push({
+        ctx: opts.ctx,
+        sessionId: opts.sessionId,
+        text: opts.text,
+        agent: opts.agent ?? "Astro",
+        retry: { maxAttempts: 4, baseDelayMs: 250 },
+    });
+    // Fire-and-forget; queue drain is serialized by isInjecting.
+    void processQueue();
 }