astrocode-workflow 0.3.4 → 0.3.5-1

package/dist/src/tools/lock.js

@@ -0,0 +1,78 @@
+import path from "node:path";
+import { tool } from "@opencode-ai/plugin/tool";
+import { getLockStatus, tryRemoveStaleLock } from "../state/repo-lock";
+export function createAstroLockStatusTool(opts) {
+    const { ctx } = opts;
+    return tool({
+        description: "Check Astrocode lock status and attempt repair. Shows diagnostics (PID, age, session) and can remove stale/dead locks.",
+        args: {
+            attempt_repair: tool.schema.boolean().default(false).describe("If true, attempt to remove stale or dead locks"),
+        },
+        execute: async ({ attempt_repair }) => {
+            const repoRoot = ctx.directory;
+            const lockPath = path.join(repoRoot, ".astro", "astro.lock");
+            const status = getLockStatus(lockPath);
+            if (!status.exists) {
+                return "✅ No lock file found. Repository is unlocked.";
+            }
+            const lines = [];
+            lines.push("# Astrocode Lock Status");
+            lines.push("");
+            lines.push("## Lock Details");
+            lines.push(`- **Path**: ${status.path}`);
+            lines.push(`- **PID**: ${status.pid} (${status.pidAlive ? '🟢 ALIVE' : '🔴 DEAD'})`);
+            lines.push(`- **Age**: ${status.ageMs ? Math.floor(status.ageMs / 1000) : '?'}s`);
+            lines.push(`- **Status**: ${status.isStale ? '⚠️ STALE' : '✅ FRESH'}`);
+            if (status.sessionId)
+                lines.push(`- **Session**: ${status.sessionId}`);
+            if (status.owner)
+                lines.push(`- **Owner**: ${status.owner}`);
+            if (status.instanceId)
+                lines.push(`- **Instance**: ${status.instanceId.substring(0, 8)}...`);
+            if (status.leaseId)
+                lines.push(`- **Lease**: ${status.leaseId.substring(0, 8)}...`);
+            if (status.createdAt)
+                lines.push(`- **Created**: ${status.createdAt}`);
+            if (status.updatedAt)
+                lines.push(`- **Updated**: ${status.updatedAt}`);
+            if (status.repoRoot)
+                lines.push(`- **Repo**: ${status.repoRoot}`);
+            lines.push(`- **Version**: ${status.version ?? 'unknown'}`);
+            lines.push("");
+            if (attempt_repair) {
+                lines.push("## Repair Attempt");
+                const result = tryRemoveStaleLock(lockPath);
+                if (result.removed) {
+                    lines.push(`✅ **Lock removed**: ${result.reason}`);
+                    lines.push("");
+                    lines.push("The repository is now unlocked and ready for use.");
+                }
+                else {
+                    lines.push(`⚠️ **Lock NOT removed**: ${result.reason}`);
+                    lines.push("");
+                    lines.push("**Recommendations**:");
+                    lines.push("- If the owning process has crashed, wait 30 seconds for automatic stale detection");
+                    lines.push("- If the process is still running, wait for it to complete");
+                    lines.push("- As a last resort, manually stop the process and run this tool again with attempt_repair=true");
+                }
+            }
+            else {
+                lines.push("## Recommendations");
+                if (!status.pidAlive) {
+                    lines.push("🔧 **Action Required**: Lock belongs to dead process. Run with `attempt_repair=true` to remove it.");
+                }
+                else if (status.isStale) {
+                    lines.push("🔧 **Action Suggested**: Lock is stale (not updated recently). Run with `attempt_repair=true` to remove it.");
+                }
+                else {
+                    lines.push("✅ Lock is active and healthy. The owning process is running normally.");
+                    lines.push("");
+                    lines.push("If you believe this is incorrect:");
+                    lines.push("- Wait 30 seconds and check again (automatic stale detection)");
+                    lines.push("- Run with `attempt_repair=true` only if you're certain the process has crashed");
+                }
+            }
+            return lines.join("\n");
+        },
+    });
+}

package/dist/src/tools/repair.js

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

package/dist/src/tools/status.js

@@ -31,7 +31,7 @@ function stageIcon(status) {
     }
 }
 export function createAstroStatusTool(opts) {
-    const { config, db } = opts;
+    const { ctx, config, db } = opts;
     return tool({
         description: "Show a compact Astrocode status dashboard: active run/stage, pipeline, story board counts, and next action.",
         args: {

package/dist/src/tools/workflow.js

@@ -1,5 +1,6 @@
 // src/tools/workflow.ts
 import { tool } from "@opencode-ai/plugin/tool";
+import path from "node:path";
 import { withTx } from "../state/db";
 import { buildContextSnapshot } from "../workflow/context";
 import { decideNextAction, createRunForStory, startStage, completeRun, failRun, getActiveRun, EVENT_TYPES, } from "../workflow/state-machine";
@@ -10,6 +11,7 @@ import { newEventId } from "../state/ids";
 import { debug } from "../shared/log";
 import { createToastManager } from "../ui/toasts";
 import { acquireRepoLock } from "../state/repo-lock";
+import { workflowRepoLock } from "../state/workflow-repo-lock";
 // Agent name mapping for case-sensitive resolution
 export const STAGE_TO_AGENT_MAP = {
     frame: "Frame",
@@ -156,200 +158,201 @@ export function createAstroWorkflowProceedTool(opts) {
             max_steps: tool.schema.number().int().positive().default(config.workflow.default_max_steps),
         },
         execute: async ({ mode, max_steps }) => {
-            // 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;
-                    }
-                    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")
+            const repoRoot = ctx.directory;
+            const lockPath = path.join(repoRoot, ".astro", "astro.lock");
+            const sessionId = ctx.sessionID;
+            return workflowRepoLock({ acquireRepoLock }, {
+                lockPath,
+                repoRoot,
+                sessionId,
+                owner: "astro_workflow_proceed",
+                fn: async () => {
+                    const steps = Math.min(max_steps, config.workflow.loop_max_steps_hard_cap);
+                    const actions = [];
+                    const warnings = [];
+                    const startedAt = nowISO();
+                    // Collect UI events emitted inside state-machine functions, then flush AFTER tx.
+                    const uiEvents = [];
+                    const emit = (e) => uiEvents.push(e);
+                    for (let i = 0; i < steps; i++) {
+                        const next = decideNextAction(db, config);
+                        if (next.kind === "idle") {
+                            actions.push("idle: no approved stories");
                             break;
-                        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)`);
-                }
-                // Housekeeping event
-                db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, NULL, NULL, ?, ?, ?)").run(newEventId(), EVENT_TYPES.WORKFLOW_PROCEED, JSON.stringify({ started_at: startedAt, mode, max_steps: steps, actions }), nowISO());
-                const active = getActiveRun(db);
-                const lines = [];
-                lines.push(`# astro_workflow_proceed`);
-                lines.push(`- mode: ${mode}`);
-                lines.push(`- steps requested: ${max_steps} (cap=${steps})`);
-                if (active)
-                    lines.push(`- active run: \`${active.run_id}\` (stage=${active.current_stage_key ?? "?"})`);
-                lines.push(``, `## Actions`);
-                for (const a of actions)
-                    lines.push(`- ${a}`);
-                if (warnings.length > 0) {
-                    lines.push(``, `## Warnings`);
-                    for (const w of warnings)
-                        lines.push(`⚠️ ${w}`);
-                }
-                return lines.join("\n").trim();
-            }
-            finally {
-                // Always release the lock
-                repoLock.release();
-            }
+                    return lines.join("\n").trim();
+                },
+            });
         },
     });
 }

package/dist/src/workflow/repair.js

@@ -43,10 +43,10 @@ export function repairState(db, config) {
             .all(active.run_id);
         if (stageRuns.length < pipeline.length) {
             const existingKeys = new Set(stageRuns.map((s) => s.stage_key));
-            const insert = db.prepare("INSERT INTO stage_runs (stage_run_id, run_id, stage_key, stage_index, status, updated_at) VALUES (?, ?, ?, ?, 'pending', ?)");
+            const insert = db.prepare("INSERT INTO stage_runs (stage_run_id, run_id, stage_key, stage_index, status, created_at, updated_at) VALUES (?, ?, ?, ?, 'pending', ?, ?)");
             pipeline.forEach((key, idx) => {
                 if (!existingKeys.has(key)) {
-                    insert.run(newStageRunId(), active.run_id, key, idx, now);
+                    insert.run(newStageRunId(), active.run_id, key, idx, now, now);
                     push(report, `Inserted missing stage_run ${key} for run ${active.run_id}`);
                 }
             });

package/package.json

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

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;
@@ -156,5 +161,16 @@ export function createInjectProvider(opts: {
       // Inject eligible injects before processing the user's message
       await injectEligibleInjects(input.sessionID);
     },
+
+    async onToolAfter(input: ToolExecuteAfterInput) {
+      if (!config.inject?.enabled) return;
+
+      // Extract sessionID (same pattern as continuation enforcer)
+      const sessionId = input.sessionID ?? (ctx as any).sessionID;
+      if (!sessionId) return;
+
+      // Inject eligible injects after tool execution
+      await injectEligibleInjects(sessionId);
+    },
   };
 }