astrocode-workflow 0.4.0 → 0.4.2

package/dist/src/workflow/state-machine.js

@@ -0,0 +1,216 @@
+import { nowISO } from "../shared/time";
+import { newEventId, newRunId, newStageRunId } from "../state/ids";
+import { warn } from "../shared/log";
+import { sha256Hex } from "../shared/hash";
+import { SCHEMA_VERSION } from "../state/schema";
+export const EVENT_TYPES = {
+    RUN_STARTED: "run.started",
+    RUN_COMPLETED: "run.completed",
+    RUN_FAILED: "run.failed",
+    RUN_ABORTED: "run.aborted",
+    RUN_GENESIS_PLANNING_ATTACHED: "run.genesis_planning_attached",
+    STAGE_STARTED: "stage.started",
+    WORKFLOW_PROCEED: "workflow.proceed",
+};
+function tableExists(db, tableName) {
+    try {
+        const row = db
+            .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?")
+            .get(tableName);
+        return row?.name === tableName;
+    }
+    catch {
+        return false;
+    }
+}
+export function getActiveRun(db) {
+    const row = db
+        .prepare("SELECT * FROM runs WHERE status = 'running' ORDER BY started_at DESC, created_at DESC LIMIT 1")
+        .get();
+    return row ?? null;
+}
+export function getStory(db, storyKey) {
+    const row = db.prepare("SELECT * FROM stories WHERE story_key = ?").get(storyKey);
+    return row ?? null;
+}
+export function getStageRuns(db, runId) {
+    return db.prepare("SELECT * FROM stage_runs WHERE run_id = ? ORDER BY stage_index ASC").all(runId);
+}
+export function getCurrentStageRun(stageRuns) {
+    const cur = stageRuns.find((s) => s.status !== "completed" && s.status !== "skipped");
+    return cur ?? null;
+}
+export function decideNextAction(db, config) {
+    const activeRun = getActiveRun(db);
+    if (!activeRun) {
+        const story = db
+            .prepare("SELECT * FROM stories WHERE state = 'approved' AND (locked_by_run_id IS NULL) ORDER BY priority DESC, approved_at ASC, created_at ASC LIMIT 1")
+            .get();
+        if (!story)
+            return { kind: "idle", reason: "no_approved_stories" };
+        return { kind: "start_run", story_key: story.story_key };
+    }
+    const stageRuns = getStageRuns(db, activeRun.run_id);
+    const current = getCurrentStageRun(stageRuns);
+    if (!current)
+        return { kind: "complete_run", run_id: activeRun.run_id };
+    if (current.status === "pending") {
+        return { kind: "delegate_stage", run_id: activeRun.run_id, stage_key: current.stage_key, stage_run_id: current.stage_run_id };
+    }
+    if (current.status === "running") {
+        return { kind: "await_stage_completion", run_id: activeRun.run_id, stage_key: current.stage_key, stage_run_id: current.stage_run_id };
+    }
+    if (current.status === "failed") {
+        return { kind: "failed", run_id: activeRun.run_id, stage_key: current.stage_key, error_text: current.error_text ?? "stage failed" };
+    }
+    warn("Unexpected stage status in decideNextAction", { status: current.status, stage_key: current.stage_key });
+    return { kind: "await_stage_completion", run_id: activeRun.run_id, stage_key: current.stage_key, stage_run_id: current.stage_run_id };
+}
+function getPipelineFromConfig(config) {
+    const pipeline = config?.workflow?.pipeline;
+    if (!Array.isArray(pipeline) || pipeline.length === 0) {
+        throw new Error("Invalid config: workflow.pipeline must be a non-empty array of stage keys.");
+    }
+    return pipeline;
+}
+function getGenesisPlanningMode(config) {
+    const raw = config?.workflow?.genesis_planning;
+    if (raw === "off" || raw === "first_story_only" || raw === "always")
+        return raw;
+    warn(`Invalid genesis_planning config: ${String(raw)}. Using default "first_story_only".`);
+    return "first_story_only";
+}
+function shouldAttachPlanningDirective(config, story) {
+    const mode = getGenesisPlanningMode(config);
+    if (mode === "off")
+        return false;
+    if (mode === "always")
+        return true;
+    return story.story_key === "S-0001";
+}
+function attachRunPlanningDirective(db, runId, story, pipeline) {
+    if (!tableExists(db, "injects"))
+        return;
+    const now = nowISO();
+    const injectId = `inj_${runId}_genesis_plan`;
+    const body = [
+        `# Genesis planning directive`,
+        ``,
+        `This run is configured to perform a planning/decomposition pass before implementation.`,
+        `Do not edit the origin story title/body. Create additional stories instead.`,
+        ``,
+        `## Required output`,
+        `- Produce 50–200 granular implementation stories with clear acceptance criteria.`,
+        `- Each story: single focused change, explicit done conditions, dependencies listed.`,
+        ``,
+        `## Context`,
+        `- Origin story: ${story.story_key} — ${story.title ?? ""}`,
+        `- Pipeline: ${pipeline.join(" → ")}`,
+        ``,
+    ].join("\n");
+    const hash = sha256Hex(body);
+    try {
+        db.prepare(`
+      INSERT OR IGNORE INTO injects (
+        inject_id, type, title, body_md, tags_json, scope, source, priority,
+        expires_at, sha256, created_at, updated_at
+      ) VALUES (
+        ?, 'note', ?, ?, '["genesis","planning","decompose"]', ?, 'tool', 100,
+        NULL, ?, ?, ?
+      )
+    `).run(injectId, "Genesis planning: decompose into stories", body, `run:${runId}`, hash, now, now);
+        db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, NULL, ?, ?, ?)").run(newEventId(), runId, EVENT_TYPES.RUN_GENESIS_PLANNING_ATTACHED, JSON.stringify({ story_key: story.story_key, inject_id: injectId }), now);
+    }
+    catch (e) {
+        warn("Failed to attach genesis planning inject", { run_id: runId, story_key: story.story_key, err: e });
+    }
+}
+export function createRunForStory(db, config, storyKey) {
+    const story = getStory(db, storyKey);
+    if (!story)
+        throw new Error(`Story not found: ${storyKey}`);
+    if (story.state !== "approved")
+        throw new Error(`Story must be approved to run: ${storyKey} (state=${story.state})`);
+    const run_id = newRunId();
+    const now = nowISO();
+    const pipeline = getPipelineFromConfig(config);
+    db.prepare("UPDATE stories SET state='in_progress', in_progress=1, locked_by_run_id=?, locked_at=?, updated_at=? WHERE story_key=?").run(run_id, now, now, storyKey);
+    db.prepare("INSERT INTO runs (run_id, story_key, status, pipeline_stages_json, current_stage_key, created_at, started_at, updated_at) VALUES (?, ?, 'running', ?, ?, ?, ?, ?)").run(run_id, storyKey, JSON.stringify(pipeline), pipeline[0] ?? null, now, now, now);
+    const insertStage = db.prepare("INSERT INTO stage_runs (stage_run_id, run_id, stage_key, stage_index, status, created_at, updated_at) VALUES (?, ?, ?, ?, 'pending', ?, ?)");
+    pipeline.forEach((stageKey, idx) => {
+        insertStage.run(newStageRunId(), run_id, stageKey, idx, now, now);
+    });
+    db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, NULL, ?, ?, ?)").run(newEventId(), run_id, EVENT_TYPES.RUN_STARTED, JSON.stringify({ story_key: storyKey, pipeline }), now);
+    if (shouldAttachPlanningDirective(config, story)) {
+        attachRunPlanningDirective(db, run_id, story, pipeline);
+    }
+    db.prepare(`
+    INSERT INTO repo_state (id, schema_version, created_at, updated_at, last_run_id, last_story_key, last_event_at)
+    VALUES (1, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET
+      last_run_id=excluded.last_run_id,
+      last_story_key=excluded.last_story_key,
+      last_event_at=excluded.last_event_at,
+      updated_at=excluded.updated_at
+  `).run(SCHEMA_VERSION, now, now, now, run_id, storyKey, now);
+    return { run_id };
+}
+export function startStage(db, runId, stageKey, meta, emit) {
+    const now = nowISO();
+    const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId);
+    if (!run)
+        throw new Error(`Run not found: ${runId}`);
+    if (run.status !== "running")
+        throw new Error(`Run is not running: ${runId} (status=${run.status})`);
+    const stage = db.prepare("SELECT * FROM stage_runs WHERE run_id=? AND stage_key=?").get(runId, stageKey);
+    if (!stage)
+        throw new Error(`Stage run not found: ${runId}/${stageKey}`);
+    if (stage.status !== "pending")
+        throw new Error(`Stage is not pending: ${stageKey} (status=${stage.status})`);
+    db.prepare("UPDATE stage_runs SET status='running', started_at=?, updated_at=?, subagent_type=COALESCE(?, subagent_type), subagent_session_id=COALESCE(?, subagent_session_id) WHERE stage_run_id=?").run(now, now, meta?.subagent_type ?? null, meta?.subagent_session_id ?? null, stage.stage_run_id);
+    db.prepare("UPDATE runs SET current_stage_key=?, updated_at=? WHERE run_id=?").run(stageKey, now, runId);
+    db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, ?, ?, ?, ?)").run(newEventId(), runId, stageKey, EVENT_TYPES.STAGE_STARTED, JSON.stringify({ subagent_type: meta?.subagent_type ?? null }), now);
+    db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
+    // ✅ Explicit wiring point (requested): stage movement
+    emit?.({ kind: "stage_started", run_id: runId, stage_key: stageKey, agent_name: meta?.subagent_type });
+}
+export function completeRun(db, runId, emit) {
+    const now = nowISO();
+    const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId);
+    if (!run)
+        throw new Error(`Run not found: ${runId}`);
+    if (run.status !== "running")
+        throw new Error(`Run not running: ${runId} (status=${run.status})`);
+    const stageRuns = getStageRuns(db, runId);
+    const incomplete = stageRuns.find((s) => s.status !== "completed" && s.status !== "skipped");
+    if (incomplete)
+        throw new Error(`Cannot complete run: stage ${incomplete.stage_key} is ${incomplete.status}`);
+    db.prepare("UPDATE runs SET status='completed', completed_at=?, updated_at=?, current_stage_key=NULL WHERE run_id=?").run(now, now, runId);
+    db.prepare("UPDATE stories SET state='done', in_progress=0, locked_by_run_id=NULL, locked_at=NULL, updated_at=? WHERE story_key=?").run(now, run.story_key);
+    db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, NULL, ?, ?, ?)").run(newEventId(), runId, EVENT_TYPES.RUN_COMPLETED, JSON.stringify({ story_key: run.story_key }), now);
+    db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
+    // ✅ Explicit wiring point (requested): run closed success
+    emit?.({ kind: "run_completed", run_id: runId, story_key: run.story_key });
+}
+export function failRun(db, runId, stageKey, errorText, emit) {
+    const now = nowISO();
+    const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId);
+    if (!run)
+        throw new Error(`Run not found: ${runId}`);
+    db.prepare("UPDATE runs SET status='failed', error_text=?, updated_at=?, completed_at=? WHERE run_id=?").run(errorText, now, now, runId);
+    db.prepare("UPDATE stories SET state='blocked', in_progress=0, locked_by_run_id=NULL, locked_at=NULL, updated_at=? WHERE story_key=?").run(now, run.story_key);
+    db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, ?, ?, ?, ?)").run(newEventId(), runId, stageKey, EVENT_TYPES.RUN_FAILED, JSON.stringify({ error_text: errorText }), now);
+    db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
+    // ✅ Explicit wiring point (requested): run closed failure
+    emit?.({ kind: "run_failed", run_id: runId, story_key: run.story_key, stage_key: stageKey, error_text: errorText });
+}
+export function abortRun(db, runId, reason) {
+    const now = nowISO();
+    const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId);
+    if (!run)
+        throw new Error(`Run not found: ${runId}`);
+    db.prepare("UPDATE runs SET status='aborted', error_text=?, updated_at=?, completed_at=? WHERE run_id=?").run(reason, now, now, runId);
+    db.prepare("UPDATE stories SET state='approved', in_progress=0, locked_by_run_id=NULL, locked_at=NULL, updated_at=? WHERE story_key=?").run(now, run.story_key);
+    db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, NULL, ?, ?, ?)").run(newEventId(), runId, EVENT_TYPES.RUN_ABORTED, JSON.stringify({ reason }), now);
+    db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
+}

package/dist/src/workflow/story-helpers.d.ts

@@ -0,0 +1,9 @@
+import type { SqliteDb } from "../state/db";
+export declare function nextStoryKey(db: SqliteDb): string;
+export declare function insertStory(db: SqliteDb, opts: {
+    title: string;
+    body_md?: string;
+    priority?: number;
+    epic_key?: string | null;
+    state?: string;
+}): string;

package/dist/src/workflow/story-helpers.js

@@ -0,0 +1,13 @@
+import { nowISO } from "../shared/time";
+export function nextStoryKey(db) {
+    const row = db.prepare("SELECT next_story_num FROM story_keyseq WHERE id=1").get();
+    const n = row?.next_story_num ?? 1;
+    db.prepare("UPDATE story_keyseq SET next_story_num=? WHERE id=1").run(n + 1);
+    return `S-${String(n).padStart(4, "0")}`;
+}
+export function insertStory(db, opts) {
+    const now = nowISO();
+    const key = nextStoryKey(db);
+    db.prepare("INSERT INTO stories (story_key, epic_key, title, body_md, state, priority, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)").run(key, opts.epic_key ?? null, opts.title, opts.body_md ?? "", opts.state ?? "queued", opts.priority ?? 0, now, now);
+    return key;
+}

package/dist/state/db.d.ts

@@ -7,6 +7,7 @@ export declare function configurePragmas(db: SqliteDb, pragmas: Record<string, a
 /** BEGIN IMMEDIATE transaction helper (re-entrant). */
 export declare function withTx<T>(db: SqliteDb, fn: () => T, opts?: {
     require?: boolean;
+    operation?: string;
 }): T;
 export declare function getSchemaVersion(db: SqliteDb): number;
 export declare function ensureSchema(db: SqliteDb, opts?: {

package/dist/state/db.js

@@ -5,6 +5,7 @@ import { SCHEMA_SQL, SCHEMA_VERSION } from "./schema";
 import { nowISO } from "../shared/time";
 import { info, warn } from "../shared/log";
 import { createDatabaseAdapter } from "./adapters";
+import { recordTransaction } from "../shared/metrics";
 /** Ensure directory exists for a file path. */
 function ensureParentDir(filePath) {
     const dir = path.dirname(filePath);
@@ -79,12 +80,16 @@ export function withTx(db, fn, opts) {
         return fn();
     }
     const depth = getDepth(db);
+    const isNested = depth > 0;
+    const txRecorder = recordTransaction({ nestedDepth: depth, operation: opts?.operation });
     if (depth === 0) {
+        const txStart = txRecorder.start();
         db.exec("BEGIN IMMEDIATE");
         setDepth(db, 1);
         try {
             const out = fn();
             db.exec("COMMIT");
+            txRecorder.end(txStart, true);
             return out;
         }
         catch (e) {
@@ -94,6 +99,7 @@ export function withTx(db, fn, opts) {
             catch {
                 // ignore
             }
+            txRecorder.end(txStart, false);
             throw e;
         }
         finally {
@@ -103,11 +109,13 @@ export function withTx(db, fn, opts) {
     // Nested: use SAVEPOINT
     const nextDepth = depth + 1;
     const sp = savepointName(nextDepth);
+    const txStart = txRecorder.start();
     db.exec(`SAVEPOINT ${sp}`);
     setDepth(db, nextDepth);
     try {
         const out = fn();
         db.exec(`RELEASE SAVEPOINT ${sp}`);
+        txRecorder.end(txStart, true);
         return out;
     }
     catch (e) {
@@ -123,6 +131,7 @@ export function withTx(db, fn, opts) {
         catch {
             // ignore
         }
+        txRecorder.end(txStart, false);
         throw e;
     }
     finally {

package/dist/state/repo-lock.d.ts

@@ -0,0 +1,3 @@
+export declare function acquireRepoLock(lockPath: string): {
+    release: () => void;
+};

package/dist/state/repo-lock.js

@@ -0,0 +1,29 @@
+// src/state/repo-lock.ts
+import fs from "node:fs";
+import path from "node:path";
+export function acquireRepoLock(lockPath) {
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    let fd;
+    try {
+        fd = fs.openSync(lockPath, "wx"); // exclusive create
+    }
+    catch (e) {
+        const msg = e?.code === "EEXIST"
+            ? `Astrocode lock is already held (${lockPath}). Another opencode process is running in this repo.`
+            : `Failed to acquire lock (${lockPath}): ${e?.message ?? String(e)}`;
+        throw new Error(msg);
+    }
+    fs.writeFileSync(fd, `${process.pid}\n`, "utf8");
+    return {
+        release: () => {
+            try {
+                fs.closeSync(fd);
+            }
+            catch { }
+            try {
+                fs.unlinkSync(lockPath);
+            }
+            catch { }
+        },
+    };
+}

package/dist/test/integration/db-transactions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/integration/db-transactions.test.js

@@ -0,0 +1,126 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { openSqlite, withTx, ensureSchema } from '../../src/state/db';
+import { metrics } from '../../src/shared/metrics';
+import fs from 'node:fs';
+describe('Database Transaction Integration Tests', () => {
+    const testDbPath = '.astro/test.db';
+    let db;
+    beforeEach(() => {
+        // Clean up any existing test DB
+        if (fs.existsSync(testDbPath)) {
+            fs.unlinkSync(testDbPath);
+        }
+        db = openSqlite(testDbPath);
+        ensureSchema(db);
+        metrics.clear(); // Reset metrics before each test
+    });
+    afterEach(() => {
+        if (db) {
+            db.close();
+        }
+        if (fs.existsSync(testDbPath)) {
+            fs.unlinkSync(testDbPath);
+        }
+        metrics.clear();
+    });
+    it('should handle nested transactions correctly', () => {
+        let outerExecuted = false;
+        let innerExecuted = false;
+        const result = withTx(db, () => {
+            outerExecuted = true;
+            // Create a table to test nested operations
+            db.exec('CREATE TABLE test_table (id INTEGER PRIMARY KEY, value TEXT)');
+            const innerResult = withTx(db, () => {
+                innerExecuted = true;
+                db.prepare('INSERT INTO test_table (value) VALUES (?)').run('nested_value');
+                return 'inner_success';
+            });
+            db.prepare('INSERT INTO test_table (value) VALUES (?)').run('outer_value');
+            return `outer_success_${innerResult}`;
+        });
+        expect(outerExecuted).toBe(true);
+        expect(innerExecuted).toBe(true);
+        expect(result).toBe('outer_success_inner_success');
+        // Verify both inserts succeeded
+        const rows = db.prepare('SELECT value FROM test_table ORDER BY id').all();
+        expect(rows).toHaveLength(2);
+        expect(rows[0].value).toBe('nested_value');
+        expect(rows[1].value).toBe('outer_value');
+    });
+    it('should collect transaction metrics', () => {
+        withTx(db, () => {
+            db.exec('CREATE TABLE metrics_test (id INTEGER PRIMARY KEY)');
+            db.prepare('INSERT INTO metrics_test (id) VALUES (?)').run(1);
+        }, { operation: 'test_operation' });
+        const txStats = metrics.getTransactionStats();
+        expect(txStats).toBeTruthy();
+        expect(txStats.total).toBe(1);
+        expect(txStats.successful).toBe(1);
+        expect(txStats.failed).toBe(0);
+        expect(txStats.successRate).toBe(1);
+        expect(txStats.avgDuration).toBeGreaterThan(0);
+    });
+    it('should handle transaction failures correctly', () => {
+        let outerExecuted = false;
+        expect(() => {
+            withTx(db, () => {
+                outerExecuted = true;
+                db.exec('CREATE TABLE failure_test (id INTEGER PRIMARY KEY)');
+                // This should cause a failure
+                withTx(db, () => {
+                    throw new Error('Intentional failure');
+                });
+            });
+        }).toThrow('Intentional failure');
+        expect(outerExecuted).toBe(true);
+        // Verify transaction was rolled back - table should not exist
+        const tableExists = db.prepare(`
+      SELECT name FROM sqlite_master
+      WHERE type='table' AND name='failure_test'
+    `).get();
+        expect(tableExists).toBeUndefined();
+    });
+    it('should handle SAVEPOINT nesting correctly', () => {
+        let level1Executed = false;
+        let level2Executed = false;
+        let level3Executed = false;
+        withTx(db, () => {
+            level1Executed = true;
+            db.exec('CREATE TABLE nesting_test (level INTEGER, value TEXT)');
+            withTx(db, () => {
+                level2Executed = true;
+                db.prepare('INSERT INTO nesting_test (level, value) VALUES (?, ?)').run(2, 'level2');
+                withTx(db, () => {
+                    level3Executed = true;
+                    db.prepare('INSERT INTO nesting_test (level, value) VALUES (?, ?)').run(3, 'level3');
+                });
+                db.prepare('INSERT INTO nesting_test (level, value) VALUES (?, ?)').run(2, 'level2_after');
+            });
+            db.prepare('INSERT INTO nesting_test (level, value) VALUES (?, ?)').run(1, 'level1');
+        });
+        expect(level1Executed).toBe(true);
+        expect(level2Executed).toBe(true);
+        expect(level3Executed).toBe(true);
+        const rows = db.prepare('SELECT level, value FROM nesting_test ORDER BY rowid').all();
+        expect(rows).toHaveLength(4);
+        expect(rows.map(r => r.value)).toEqual(['level2', 'level3', 'level2_after', 'level1']);
+    });
+    it('should maintain metrics across multiple nested transactions', () => {
+        // Execute multiple nested transactions
+        for (let i = 0; i < 3; i++) {
+            withTx(db, () => {
+                withTx(db, () => {
+                    withTx(db, () => {
+                        // Do some work
+                        db.prepare('SELECT 1').get();
+                    });
+                });
+            }, { operation: `test_op_${i}` });
+        }
+        const txStats = metrics.getTransactionStats();
+        expect(txStats).toBeTruthy();
+        expect(txStats.total).toBe(9); // 3 outer + 6 inner (2 per outer) + 0 nested (nested count as separate)
+        expect(txStats.successful).toBe(9);
+        expect(txStats.avgNestedDepth).toBeGreaterThan(0);
+    });
+});

package/dist/test/integration/injection-metrics.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/integration/injection-metrics.test.js

@@ -0,0 +1,129 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { injectChatPrompt } from '../../src/ui/inject';
+import { metrics } from '../../src/shared/metrics';
+describe('Injection Integration Tests', () => {
+    beforeEach(() => {
+        metrics.clear();
+    });
+    afterEach(() => {
+        metrics.clear();
+    });
+    it('should record successful injection metrics', async () => {
+        const mockCtx = {
+            client: {
+                session: {
+                    prompt: vi.fn().mockResolvedValue(undefined)
+                }
+            },
+            sessionID: 'test-session-123'
+        };
+        await injectChatPrompt({
+            ctx: mockCtx,
+            sessionId: 'test-session-123',
+            text: 'Test message',
+            agent: 'TestAgent'
+        });
+        const injectionStats = metrics.getInjectionStats();
+        expect(injectionStats).toBeTruthy();
+        expect(injectionStats.total).toBe(1);
+        expect(injectionStats.successful).toBe(1);
+        expect(injectionStats.failed).toBe(0);
+        expect(injectionStats.successRate).toBe(1);
+        expect(injectionStats.avgAttempts).toBe(1);
+        expect(injectionStats.avgDuration).toBeGreaterThan(0);
+    });
+    it('should record failed injection metrics', async () => {
+        const mockCtx = {
+            client: {
+                session: {
+                    prompt: vi.fn().mockRejectedValue(new Error('API unavailable'))
+                }
+            },
+            sessionID: 'test-session-456'
+        };
+        await expect(injectChatPrompt({
+            ctx: mockCtx,
+            sessionId: 'test-session-456',
+            text: 'Test message that will fail',
+            agent: 'TestAgent'
+        })).rejects.toThrow('API unavailable');
+        const injectionStats = metrics.getInjectionStats();
+        expect(injectionStats).toBeTruthy();
+        expect(injectionStats.total).toBe(1);
+        expect(injectionStats.successful).toBe(0);
+        expect(injectionStats.failed).toBe(1);
+        expect(injectionStats.successRate).toBe(0);
+    });
+    it('should handle per-session queuing correctly', async () => {
+        const mockCtx1 = {
+            client: {
+                session: {
+                    prompt: vi.fn().mockResolvedValue(undefined)
+                }
+            },
+            sessionID: 'session-1'
+        };
+        const mockCtx2 = {
+            client: {
+                session: {
+                    prompt: vi.fn().mockResolvedValue(undefined)
+                }
+            },
+            sessionID: 'session-2'
+        };
+        // Start multiple injections for different sessions
+        const promise1 = injectChatPrompt({
+            ctx: mockCtx1,
+            sessionId: 'session-1',
+            text: 'Message 1',
+            agent: 'Agent1'
+        });
+        const promise2 = injectChatPrompt({
+            ctx: mockCtx2,
+            sessionId: 'session-2',
+            text: 'Message 2',
+            agent: 'Agent2'
+        });
+        const promise3 = injectChatPrompt({
+            ctx: mockCtx1,
+            sessionId: 'session-1',
+            text: 'Message 3',
+            agent: 'Agent1'
+        });
+        await Promise.all([promise1, promise2, promise3]);
+        const injectionStats = metrics.getInjectionStats();
+        expect(injectionStats).toBeTruthy();
+        expect(injectionStats.total).toBe(3);
+        expect(injectionStats.successful).toBe(3);
+    });
+    it('should record errors for permanently failed injections', async () => {
+        const mockCtx = {
+            client: {
+                session: {
+                    prompt: vi.fn()
+                        .mockRejectedValueOnce(new Error('Attempt 1'))
+                        .mockRejectedValueOnce(new Error('Attempt 2'))
+                        .mockRejectedValueOnce(new Error('Attempt 3'))
+                        .mockRejectedValueOnce(new Error('Attempt 4'))
+                }
+            },
+            sessionID: 'failing-session'
+        };
+        await expect(injectChatPrompt({
+            ctx: mockCtx,
+            sessionId: 'failing-session',
+            text: 'This will fail permanently',
+            agent: 'FailingAgent'
+        })).rejects.toThrow();
+        const injectionStats = metrics.getInjectionStats();
+        expect(injectionStats).toBeTruthy();
+        expect(injectionStats.total).toBe(1);
+        expect(injectionStats.successful).toBe(0);
+        expect(injectionStats.failed).toBe(1);
+        expect(injectionStats.avgAttempts).toBe(4); // Should try 4 times
+        // Check that error was recorded
+        const systemMetrics = metrics.getMetrics();
+        expect(systemMetrics.errors.length).toBeGreaterThan(0);
+        expect(systemMetrics.errors.some(e => e.type === 'injection_failure')).toBe(true);
+    });
+});

package/dist/tools/health.d.ts

@@ -0,0 +1,8 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+export declare function createAstroHealthTool(opts: {
+    ctx: any;
+    config: AstrocodeConfig;
+    db: SqliteDb;
+}): ToolDefinition;