astrocode-workflow 0.4.0 → 0.4.2

package/dist/tools/workflow.js

@@ -9,6 +9,7 @@ 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";
 // Agent name mapping for case-sensitive resolution
 export const STAGE_TO_AGENT_MAP = {
     frame: "Frame",
@@ -155,191 +156,200 @@ export function createAstroWorkflowProceedTool(opts) {
             max_steps: tool.schema.number().int().positive().default(config.workflow.default_max_steps),
         },
         execute: async ({ mode, max_steps }) => {
-            const sessionId = ctx.sessionID;
-            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")
+            // Acquire repo lock to ensure no concurrent workflow operations
+            const lockPath = `${ctx.directory}/.astro/astro.lock`;
+            const repoLock = acquireRepoLock(lockPath);
+            try {
+                const sessionId = ctx.sessionID;
+                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;
-                    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 (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)) {
-                            console.warn(`[Astrocode] Orchestrator ${agentName} not available. Falling back to General.`);
-                            agentName = "General";
+                            const originalAgent = agentName;
+                            console.warn(`[Astrocode] Agent ${agentName} not found. Falling back to orchestrator.`);
+                            agentName = config.agents?.orchestrator_name || "Astro";
                             if (!agentExists(agentName)) {
-                                throw new Error(`Critical: No agents available for delegation. Primary: ${originalAgent}, Orchestrator: ${config.agents?.orchestrator_name || "Astro"}, General: unavailable`);
+                                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" });
-                    }
-                    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) {
+                        // 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: next.run_id,
-                            next_action: `complete stage ${next.stage_key}`,
+                            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,
                         });
-                        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);
+                        // Record continuation (best-effort; no tx wrapper needed but safe either way)
+                        const h = directiveHash(delegatePrompt);
                         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" });
+                        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" });
+                        }
+                        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;
                 }
-                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",
-                        });
+                // 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);
+                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}`);
                 }
-                actions.push(`ui: flushed ${uiEvents.length} event(s)`);
+                return lines.join("\n").trim();
             }
-            // 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}`);
+            finally {
+                // Always release the lock
+                repoLock.release();
             }
-            return lines.join("\n").trim();
         },
     });
 }

package/dist/ui/inject.js

@@ -1,3 +1,5 @@
+// src/ui/inject.ts
+import { recordInjection, recordError } from "../shared/metrics";
 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
@@ -17,15 +19,24 @@ function getPromptInvoker(ctx) {
 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,
-        },
-    });
+    const injectionRecorder = recordInjection({ sessionId, attempts: item.attempts + 1, agent });
+    const injectionStart = injectionRecorder.start();
+    try {
+        const { session, prompt } = getPromptInvoker(ctx);
+        // IMPORTANT: force correct `this` binding
+        await prompt.call(session, {
+            path: { id: sessionId },
+            body: {
+                parts: [{ type: "text", text: prefixedText }],
+                agent,
+            },
+        });
+        injectionRecorder.end(injectionStart, true);
+    }
+    catch (error) {
+        injectionRecorder.end(injectionStart, false);
+        throw error;
+    }
 }
 async function runSessionQueue(sessionId) {
     if (running.has(sessionId))
@@ -48,6 +59,7 @@ async function runSessionQueue(sessionId) {
                 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}`);
+                    recordError("injection_failure", `Injection failed after ${item.attempts} attempts: ${msg}`);
                     item.reject(err);
                     continue;
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astrocode-workflow",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,12 +13,13 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "clean": "rm -rf dist"
+    "clean": "rm -rf dist",
+    "test": "vitest",
+    "test:run": "vitest run"
   },
   "dependencies": {
     "@opencode-ai/plugin": "^1.1.19",
     "@opencode-ai/sdk": "^1.1.19",
-    "astrocode-workflow": "^0.1.51",
     "jsonc-parser": "^3.2.0",
     "zod": "4.1.8"
   },
@@ -28,6 +29,7 @@
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.12",
     "@types/node": "^20.12.12",
-    "typescript": "^5.6.3"
+    "typescript": "^5.6.3",
+    "vitest": "^1.6.0"
   }
 }

package/src/astro/workflow-runner.ts

@@ -0,0 +1,16 @@
+// src/astro/workflow-runner.ts
+
+/**
+ * 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: {
+  proceedOneStep: () => Promise<{ done: boolean }>;
+}): Promise<void> {
+  while (true) {
+    const { done } = await opts.proceedOneStep();
+    if (done) return;
+  }
+}

package/src/config/schema.ts

@@ -203,6 +203,7 @@ const InjectSchema = z
     scope_allowlist: z.array(z.string()).default(["repo", "global"]),
     type_allowlist: z.array(z.string()).default(["note", "policy"]),
     max_per_turn: z.number().int().positive().default(5),
+    auto_approve_queued_stories: z.boolean().default(false).describe("Auto-approve highest priority queued story after workflow tools"),
   })
   .partial()
   .default({});

package/src/hooks/inject-provider.ts

@@ -9,6 +9,11 @@ type ChatMessageInput = {
   agent: string;
 };
 
+type ToolExecuteAfterInput = {
+  tool: string;
+  sessionID?: string;
+};
+
 type RuntimeState = {
   db: SqliteDb | null;
   limitedMode: boolean;
@@ -24,19 +29,30 @@ export function createInjectProvider(opts: {
   const { db } = runtime;
 
   // Cache to avoid re-injecting the same injects repeatedly
+  // Map of inject_id -> last injected timestamp
   const injectedCache = new Map<string, number>();
 
   function shouldSkipInject(injectId: string, nowMs: number): boolean {
     const lastInjected = injectedCache.get(injectId);
     if (!lastInjected) return false;
 
-    // Skip if injected within the last 5 minutes (configurable?)
-    const cooldownMs = 5 * 60 * 1000;
+    // REDUCED cooldown from 5 minutes to 1 minute
+    // This allows injects to appear more frequently during workflow
+    const cooldownMs = 1 * 60 * 1000;
     return nowMs - lastInjected < cooldownMs;
   }
 
   function markInjected(injectId: string, nowMs: number) {
     injectedCache.set(injectId, nowMs);
+
+    // Clean up old entries to prevent memory leak
+    // Remove entries older than 10 minutes
+    const tenMinutesAgo = nowMs - (10 * 60 * 1000);
+    for (const [id, timestamp] of injectedCache.entries()) {
+      if (timestamp < tenMinutesAgo) {
+        injectedCache.delete(id);
+      }
+    }
   }
 
   function getInjectionDiagnostics(nowIso: string, scopeAllowlist: string[], typeAllowlist: string[]): any {
@@ -89,7 +105,7 @@ export function createInjectProvider(opts: {
     };
   }
 
-  async function injectEligibleInjects(sessionId: string) {
+  async function injectEligibleInjects(sessionId: string, context?: string) {
     const now = nowISO();
     const nowMs = Date.now();
 
@@ -115,7 +131,7 @@ export function createInjectProvider(opts: {
       // Log when no injects are eligible
       if (EMIT_TELEMETRY) {
         // eslint-disable-next-line no-console
-        console.log(`[Astrocode:inject] ${now} selected=${diagnostics.selected_eligible} injected=0 skipped={expired:${diagnostics.skipped.expired} scope:${diagnostics.skipped.scope} type:${diagnostics.skipped.type} deduped:0}`);
+        console.log(`[Astrocode:inject] ${now} context=${context ?? 'unknown'} selected=0 injected=0 skipped={expired:${diagnostics.skipped.expired} scope:${diagnostics.skipped.scope} type:${diagnostics.skipped.type} deduped:0}`);
       }
       return;
     }
@@ -130,21 +146,68 @@ export function createInjectProvider(opts: {
       // Format as injection message
       const formattedText = `[Inject: ${inject.title}]\n\n${inject.body_md}`;
 
+      try {
+        await injectChatPrompt({
+          ctx,
+          sessionId,
+          text: formattedText,
+          agent: "Astrocode"
+        });
+
+        injected++;
+        markInjected(inject.inject_id, nowMs);
+      } catch (err) {
+        // Log injection failures but don't crash
+        // eslint-disable-next-line no-console
+        console.error(`[Astrocode:inject] Failed to inject ${inject.inject_id}:`, err);
+      }
+    }
+
+    // Log diagnostic summary
+    if (EMIT_TELEMETRY || injected > 0) {
+      // eslint-disable-next-line no-console
+      console.log(`[Astrocode:inject] ${now} context=${context ?? 'unknown'} selected=${diagnostics.selected_eligible} injected=${injected} skipped={expired:${diagnostics.skipped.expired} scope:${diagnostics.skipped.scope} type:${diagnostics.skipped.type} deduped:${skippedDeduped}}`);
+    }
+  }
+
+  // Workflow-related tools that should trigger inject + auto-approval
+  const WORKFLOW_TOOLS = new Set([
+    'astro_workflow_proceed',
+    'astro_story_queue',
+    'astro_story_approve',
+    'astro_stage_start',
+    'astro_stage_complete',
+    'astro_stage_fail',
+    'astro_run_abort',
+  ]);
+
+  // Auto-approve queued stories if enabled
+  async function maybeAutoApprove(sessionId: string) {
+    if (!config.inject?.auto_approve_queued_stories) return;
+
+    try {
+      // Get all queued stories
+      const queued = db.prepare("SELECT story_key, title FROM stories WHERE state='queued' ORDER BY priority DESC, created_at ASC").all() as Array<{ story_key: string; title: string }>;
+
+      if (queued.length === 0) return;
+
+      // Auto-approve the highest priority queued story
+      const story = queued[0];
+      db.prepare("UPDATE stories SET state='approved', updated_at=? WHERE story_key=?").run(nowISO(), story.story_key);
+
+      // eslint-disable-next-line no-console
+      console.log(`[Astrocode:inject] Auto-approved story ${story.story_key}: ${story.title}`);
+
+      // Inject a notification about the auto-approval
       await injectChatPrompt({
         ctx,
         sessionId,
-        text: formattedText,
+        text: `✅ Auto-approved story ${story.story_key}: ${story.title}`,
         agent: "Astrocode"
       });
-
-      injected++;
-      markInjected(inject.inject_id, nowMs);
-    }
-
-    // Log diagnostic summary
-    if (EMIT_TELEMETRY) {
+    } catch (err) {
       // eslint-disable-next-line no-console
-      console.log(`[Astrocode:inject] ${now} selected=${diagnostics.selected_eligible} injected=${injected} skipped={expired:${diagnostics.skipped.expired} scope:${diagnostics.skipped.scope} type:${diagnostics.skipped.type} deduped:${skippedDeduped}}`);
+      console.error(`[Astrocode:inject] Auto-approval failed:`, err);
     }
   }
 
@@ -154,7 +217,24 @@ export function createInjectProvider(opts: {
       if (!config.inject?.enabled) return;
 
       // Inject eligible injects before processing the user's message
-      await injectEligibleInjects(input.sessionID);
+      await injectEligibleInjects(input.sessionID, 'chat_message');
+    },
+
+    async onToolAfter(input: ToolExecuteAfterInput) {
+      if (!config.inject?.enabled) return;
+
+      // Only inject after workflow-related tools
+      if (!WORKFLOW_TOOLS.has(input.tool)) return;
+
+      // Extract sessionID (same pattern as continuation enforcer)
+      const sessionId = input.sessionID ?? (ctx as any).sessionID;
+      if (!sessionId) return;
+
+      // Auto-approve queued stories if enabled
+      await maybeAutoApprove(sessionId);
+
+      // Inject eligible injects after workflow tool execution
+      await injectEligibleInjects(sessionId, `tool_after:${input.tool}`);
     },
   };
 }