astrocode-workflow 0.3.0 → 0.3.2

package/dist/src/workflow/repair.js

@@ -0,0 +1,99 @@
+import { nowISO } from "../shared/time";
+import { newEventId, newStageRunId } from "../state/ids";
+function push(report, line) {
+    report.actions.push(line);
+}
+function warn(report, line) {
+    report.warnings.push(line);
+}
+export function repairState(db, config) {
+    const report = { actions: [], warnings: [] };
+    const now = nowISO();
+    // 1) Multiple running runs -> abort extras (keep most recent started_at)
+    const running = db
+        .prepare("SELECT * FROM runs WHERE status='running' ORDER BY started_at DESC, created_at DESC")
+        .all();
+    if (running.length > 1) {
+        const keep = running[0];
+        for (const r of running.slice(1)) {
+            db.prepare("UPDATE runs SET status='aborted', error_text=?, completed_at=?, updated_at=? WHERE run_id=?").run("repair: multiple running runs", now, now, r.run_id);
+            // unlock story
+            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, r.story_key);
+            db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, NULL, 'run.aborted', ?, ?)").run(newEventId(), r.run_id, JSON.stringify({ reason: "repair: multiple running runs" }), now);
+            push(report, `Aborted extra running run ${r.run_id} (kept ${keep.run_id})`);
+        }
+    }
+    // 2) Fix story locks for the active run
+    const active = db.prepare("SELECT * FROM runs WHERE status='running' ORDER BY started_at DESC LIMIT 1").get();
+    if (active) {
+        const story = db.prepare("SELECT * FROM stories WHERE story_key=?").get(active.story_key);
+        if (!story) {
+            warn(report, `Active run ${active.run_id} references missing story ${active.story_key}`);
+        }
+        else {
+            if (story.locked_by_run_id !== active.run_id || story.in_progress !== 1 || story.state !== "in_progress") {
+                db.prepare("UPDATE stories SET state='in_progress', in_progress=1, locked_by_run_id=?, locked_at=COALESCE(locked_at, ?), updated_at=? WHERE story_key=?").run(active.run_id, now, now, story.story_key);
+                push(report, `Repaired story lock for ${story.story_key} to run ${active.run_id}`);
+            }
+        }
+        // 3) Ensure stage_runs exist for pipeline
+        const pipeline = JSON.parse(active.pipeline_stages_json ?? "[]");
+        const stageRuns = db
+            .prepare("SELECT * FROM stage_runs WHERE run_id=? ORDER BY stage_index ASC")
+            .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', ?)");
+            pipeline.forEach((key, idx) => {
+                if (!existingKeys.has(key)) {
+                    insert.run(newStageRunId(), active.run_id, key, idx, now);
+                    push(report, `Inserted missing stage_run ${key} for run ${active.run_id}`);
+                }
+            });
+        }
+        // 4) If current_stage_key missing, set to first incomplete
+        const refreshed = db
+            .prepare("SELECT * FROM stage_runs WHERE run_id=? ORDER BY stage_index ASC")
+            .all(active.run_id);
+        const cur = refreshed.find((s) => s.status !== "completed" && s.status !== "skipped");
+        if (cur && active.current_stage_key !== cur.stage_key) {
+            db.prepare("UPDATE runs SET current_stage_key=?, updated_at=? WHERE run_id=?").run(cur.stage_key, now, active.run_id);
+            push(report, `Set run.current_stage_key to ${cur.stage_key} for ${active.run_id}`);
+        }
+    }
+    // 5) Orphaned story locks (in_progress=1 but no running run)
+    const lockedStories = db
+        .prepare("SELECT * FROM stories WHERE in_progress=1")
+        .all();
+    for (const s of lockedStories) {
+        const run = s.locked_by_run_id
+            ? db.prepare("SELECT * FROM runs WHERE run_id=?").get(s.locked_by_run_id)
+            : undefined;
+        if (!run || run.status !== "running") {
+            db.prepare("UPDATE stories SET in_progress=0, locked_by_run_id=NULL, locked_at=NULL, updated_at=? WHERE story_key=?").run(now, s.story_key);
+            // Keep state conservative: if it was in_progress but no run, revert to approved.
+            db.prepare("UPDATE stories SET state='approved', updated_at=? WHERE story_key=? AND state='in_progress'").run(now, s.story_key);
+            push(report, `Cleared orphaned lock on story ${s.story_key}`);
+        }
+    }
+    if (!report.actions.length && !report.warnings.length) {
+        report.actions.push("No repairs needed.");
+    }
+    // Event marker
+    db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, NULL, NULL, 'repair.completed', ?, ?)").run(newEventId(), JSON.stringify({ actions: report.actions, warnings: report.warnings, schema: config.db.schema_version_required }), now);
+    return report;
+}
+export function formatRepairReport(report) {
+    const lines = [];
+    lines.push("# Astrocode repair report");
+    lines.push("");
+    lines.push("## Actions");
+    for (const a of report.actions)
+        lines.push(`- ${a}`);
+    if (report.warnings.length) {
+        lines.push("", "## Warnings");
+        for (const w of report.warnings)
+            lines.push(`- ${w}`);
+    }
+    return lines.join("\n").trim();
+}

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

@@ -0,0 +1,86 @@
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+import type { RunRow, StageKey, StageRunRow, StoryRow } from "../state/types";
+export declare const EVENT_TYPES: {
+    readonly RUN_STARTED: "run.started";
+    readonly RUN_COMPLETED: "run.completed";
+    readonly RUN_FAILED: "run.failed";
+    readonly RUN_ABORTED: "run.aborted";
+    readonly RUN_GENESIS_PLANNING_ATTACHED: "run.genesis_planning_attached";
+    readonly STAGE_STARTED: "stage.started";
+    readonly WORKFLOW_PROCEED: "workflow.proceed";
+};
+export type UiEmitEvent = {
+    kind: "stage_started";
+    run_id: string;
+    stage_key: StageKey;
+    agent_name?: string;
+} | {
+    kind: "run_completed";
+    run_id: string;
+    story_key: string;
+} | {
+    kind: "run_failed";
+    run_id: string;
+    story_key: string;
+    stage_key: StageKey;
+    error_text: string;
+};
+export type UiEmit = (e: UiEmitEvent) => void;
+/**
+ * PLANNING-FIRST REDESIGN
+ * ----------------------
+ * Never mutate story title/body.
+ *
+ * Deterministic trigger:
+ * - config.workflow.genesis_planning:
+ *    - "off"             => never attach directive
+ *    - "first_story_only"=> only when story_key === "S-0001"
+ *    - "always"          => attach for every run
+ *
+ * Contract: DB is already initialized before workflow is used:
+ * - schema tables exist
+ * - repo_state singleton row (id=1) exists
+ *
+ * IMPORTANT: Do NOT call withTx() in here. The caller owns transaction boundaries.
+ */
+export type NextAction = {
+    kind: "idle";
+    reason: "no_approved_stories";
+} | {
+    kind: "start_run";
+    story_key: string;
+} | {
+    kind: "delegate_stage";
+    run_id: string;
+    stage_key: StageKey;
+    stage_run_id: string;
+} | {
+    kind: "await_stage_completion";
+    run_id: string;
+    stage_key: StageKey;
+    stage_run_id: string;
+} | {
+    kind: "complete_run";
+    run_id: string;
+} | {
+    kind: "failed";
+    run_id: string;
+    stage_key: StageKey;
+    error_text: string;
+};
+export declare function getActiveRun(db: SqliteDb): RunRow | null;
+export declare function getStory(db: SqliteDb, storyKey: string): StoryRow | null;
+export declare function getStageRuns(db: SqliteDb, runId: string): StageRunRow[];
+export declare function getCurrentStageRun(stageRuns: StageRunRow[]): StageRunRow | null;
+export declare function decideNextAction(db: SqliteDb, config: AstrocodeConfig): NextAction;
+export declare function createRunForStory(db: SqliteDb, config: AstrocodeConfig, storyKey: string): {
+    run_id: string;
+};
+export declare function startStage(db: SqliteDb, runId: string, stageKey: StageKey, meta?: {
+    subagent_type?: string;
+    subagent_session_id?: string;
+}, emit?: UiEmit): void;
+export declare function completeRun(db: SqliteDb, runId: string, emit?: UiEmit): void;
+export declare function failRun(db: SqliteDb, runId: string, stageKey: StageKey, errorText: string, emit?: UiEmit): void;
+export declare function abortRun(db: SqliteDb, runId: string, reason: string): void;

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 {};