astrocode-workflow 0.0.1

package/dist/index.js

@@ -0,0 +1,108 @@
+import { loadAstrocodeConfig } from "./config/loader";
+import { createConfigHandler } from "./config/config-handler";
+import { openSqlite, configurePragmas, ensureSchema } from "./state/db";
+import { getAstroPaths, ensureAstroDirs } from "./shared/paths";
+import { createAstroTools } from "./tools";
+import { createContinuationEnforcer } from "./hooks/continuation-enforcer";
+import { createToolOutputTruncatorHook } from "./hooks/tool-output-truncator";
+import { createToastManager } from "./ui/toasts";
+console.log("Astrocode plugin loading...");
+const Astrocode = async (ctx) => {
+    const repoRoot = ctx.directory;
+    // Always load config first - this provides defaults even in limited mode
+    let pluginConfig = loadAstrocodeConfig(repoRoot);
+    // Always ensure .astro directories exist, even in limited mode
+    const paths = getAstroPaths(repoRoot, pluginConfig.db.path);
+    ensureAstroDirs(paths);
+    let db = null;
+    let tools = null;
+    let configHandler = null;
+    let continuation = null;
+    let truncatorHook = null;
+    let toasts = null;
+    try {
+        db = openSqlite(paths.dbPath, { busyTimeoutMs: pluginConfig.db.busy_timeout_ms });
+        configurePragmas(db, pluginConfig.db.pragmas);
+        ensureSchema(db, { allowAutoMigrate: pluginConfig.db.allow_auto_migrate, failOnDowngrade: pluginConfig.db.fail_on_downgrade });
+        // Database initialized successfully
+        configHandler = createConfigHandler({ pluginConfig });
+        tools = createAstroTools({ ctx, config: pluginConfig, db });
+        continuation = createContinuationEnforcer({ ctx, config: pluginConfig, db });
+        truncatorHook = createToolOutputTruncatorHook({ ctx, config: pluginConfig, db });
+        toasts = createToastManager({ ctx, throttleMs: pluginConfig.ui.toasts.throttle_ms });
+    }
+    catch (e) {
+        // Database initialization failed - setup limited mode
+        // Reload config to ensure all defaults are present
+        pluginConfig = loadAstrocodeConfig(repoRoot);
+        // Modify config for limited mode
+        pluginConfig.disabled_hooks = [...(pluginConfig.disabled_hooks || []), "continuation-enforcer", "tool-output-truncator"];
+        pluginConfig.ui.toasts.enabled = false;
+        // Create limited functionality
+        db = null;
+        configHandler = createConfigHandler({ pluginConfig });
+        tools = createAstroTools({ ctx, config: pluginConfig, db });
+        continuation = null;
+        truncatorHook = null;
+        toasts = null;
+    }
+    return {
+        name: "Astrocode",
+        // Merge agents + slash commands into system config
+        config: configHandler,
+        // Register tools
+        tool: tools,
+        // Limit created subagents from spawning more subagents (OMO-style).
+        "tool.execute.before": async (input, output) => {
+            if (!pluginConfig.permissions.enforce_task_tool_restrictions)
+                return;
+            if (input.tool !== "task")
+                return;
+            output.args = output.args ?? {};
+            const toolsMap = { ...(output.args.tools ?? {}) };
+            if (pluginConfig.permissions.deny_delegate_task_in_subagents) {
+                toolsMap.delegate_task = false;
+            }
+            output.args.tools = toolsMap;
+        },
+        "tool.execute.after": async (input, output) => {
+            // Truncate huge tool outputs to artifacts
+            if (truncatorHook && !pluginConfig.disabled_hooks.includes("tool-output-truncator")) {
+                await truncatorHook(input, output);
+            }
+            // Schedule continuation (do not immediately spam)
+            if (continuation && !pluginConfig.disabled_hooks.includes("continuation-enforcer")) {
+                await continuation.onToolAfter(input);
+            }
+        },
+        "chat.message": async (input, output) => {
+            if (continuation && !pluginConfig.disabled_hooks.includes("continuation-enforcer")) {
+                await continuation.onChatMessage(input);
+            }
+            return output;
+        },
+        event: async (input) => {
+            if (continuation && !pluginConfig.disabled_hooks.includes("continuation-enforcer")) {
+                await continuation.onEvent(input);
+            }
+        },
+        // Best-effort cleanup
+        close: async () => {
+            try {
+                db.close();
+            }
+            catch {
+                // ignore
+            }
+            if (toasts && pluginConfig.ui.toasts.enabled) {
+                try {
+                    await toasts.show({ title: "Astrocode", message: "Plugin closed", variant: "info" });
+                }
+                catch {
+                    // ignore
+                }
+            }
+        },
+    };
+};
+export default Astrocode;

package/dist/shared/deep-merge.d.ts

@@ -0,0 +1,8 @@
+export declare function isPlainObject(v: unknown): v is Record<string, unknown>;
+/**
+ * Deep merge:
+ * - objects merge recursively
+ * - arrays replace
+ * - primitives overwrite
+ */
+export declare function deepMerge<T>(base: T, patch: Partial<T>): T;

package/dist/shared/deep-merge.js

@@ -0,0 +1,25 @@
+export function isPlainObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/**
+ * Deep merge:
+ * - objects merge recursively
+ * - arrays replace
+ * - primitives overwrite
+ */
+export function deepMerge(base, patch) {
+    if (!isPlainObject(base) || !isPlainObject(patch)) {
+        return patch ?? base;
+    }
+    const out = { ...base };
+    for (const [k, v] of Object.entries(patch)) {
+        const cur = out[k];
+        if (isPlainObject(cur) && isPlainObject(v)) {
+            out[k] = deepMerge(cur, v);
+        }
+        else {
+            out[k] = v;
+        }
+    }
+    return out;
+}

package/dist/shared/hash.d.ts

@@ -0,0 +1 @@
+export declare function sha256Hex(input: string | Buffer): string;

package/dist/shared/hash.js

@@ -0,0 +1,4 @@
+import { createHash } from "node:crypto";
+export function sha256Hex(input) {
+    return createHash("sha256").update(input).digest("hex");
+}

package/dist/shared/log.d.ts

@@ -0,0 +1,7 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export declare function setLogLevel(level: LogLevel): void;
+export declare function log(level: LogLevel, message: string, meta?: unknown): void;
+export declare const debug: (msg: string, meta?: unknown) => void;
+export declare const info: (msg: string, meta?: unknown) => void;
+export declare const warn: (msg: string, meta?: unknown) => void;
+export declare const error: (msg: string, meta?: unknown) => void;

package/dist/shared/log.js

@@ -0,0 +1,24 @@
+let CURRENT_LEVEL = process.env.ASTRO_LOG_LEVEL ?? "info";
+const ORDER = { debug: 10, info: 20, warn: 30, error: 40 };
+export function setLogLevel(level) {
+    CURRENT_LEVEL = level;
+}
+function shouldLog(level) {
+    return ORDER[level] >= ORDER[CURRENT_LEVEL];
+}
+export function log(level, message, meta) {
+    if (!shouldLog(level))
+        return;
+    const prefix = `[astrocode:${level}]`;
+    if (meta === undefined) {
+        // eslint-disable-next-line no-console
+        console.log(prefix, message);
+        return;
+    }
+    // eslint-disable-next-line no-console
+    console.log(prefix, message, meta);
+}
+export const debug = (msg, meta) => log("debug", msg, meta);
+export const info = (msg, meta) => log("info", msg, meta);
+export const warn = (msg, meta) => log("warn", msg, meta);
+export const error = (msg, meta) => log("error", msg, meta);

package/dist/shared/model-tuning.d.ts

@@ -0,0 +1,9 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+export type AstroCognitionPreset = "orchestrator" | "frame" | "plan" | "spec" | "implement" | "review" | "verify" | "close" | "utility";
+/**
+ * OMO-style: if GPT model => reasoningEffort/textVerbosity.
+ * Otherwise => Anthropic-style thinking budget.
+ *
+ * Not all providers honor these fields; safe to include.
+ */
+export declare function applyModelTuning(base: AgentConfig, preset: AstroCognitionPreset): AgentConfig;

package/dist/shared/model-tuning.js

@@ -0,0 +1,28 @@
+import { isGptModel } from "../agents/types";
+/**
+ * OMO-style: if GPT model => reasoningEffort/textVerbosity.
+ * Otherwise => Anthropic-style thinking budget.
+ *
+ * Not all providers honor these fields; safe to include.
+ */
+export function applyModelTuning(base, preset) {
+    const model = base.model ?? "";
+    if (!model)
+        return base;
+    if (isGptModel(model)) {
+        const reasoningEffort = preset === "orchestrator" ? "medium"
+            : preset === "implement" ? "high"
+                : "medium";
+        const textVerbosity = preset === "orchestrator" ? "low"
+            : preset === "review" ? "high"
+                : "medium";
+        const { thinking, ...rest } = base;
+        return { ...rest, reasoningEffort, textVerbosity };
+    }
+    const budgetTokens = preset === "implement" ? 32_000
+        : preset === "review" ? 24_000
+            : preset === "orchestrator" ? 16_000
+                : 12_000;
+    const { reasoningEffort, textVerbosity, ...rest } = base;
+    return { ...rest, thinking: { type: "enabled", budgetTokens } };
+}

package/dist/shared/paths.d.ts

@@ -0,0 +1,19 @@
+/** Normalize to posix-like separators for DB paths. */
+export declare function toPosix(p: string): string;
+export declare function ensureDir(p: string): void;
+export declare function joinRepo(root: string, ...parts: string[]): string;
+export type AstroPaths = {
+    repoRoot: string;
+    astroRoot: string;
+    dbPath: string;
+    runsDir: string;
+    specPath: string;
+    toolOutputDir: string;
+    configPathPreferred: string;
+    configPathFallback: string;
+};
+export declare function getAstroPaths(repoRoot: string, dbPathOverride?: string): AstroPaths;
+export declare function ensureAstroDirs(paths: AstroPaths): void;
+export declare function runDir(paths: AstroPaths, runId: string): string;
+export declare function stageDir(paths: AstroPaths, runId: string, stageKey: string): string;
+export declare function assertInsideAstro(repoRoot: string, filePath: string): void;

package/dist/shared/paths.js

@@ -0,0 +1,51 @@
+import path from "node:path";
+import fs from "node:fs";
+/** Normalize to posix-like separators for DB paths. */
+export function toPosix(p) {
+    return p.split(path.sep).join("/");
+}
+export function ensureDir(p) {
+    fs.mkdirSync(p, { recursive: true });
+}
+export function joinRepo(root, ...parts) {
+    return path.join(root, ...parts);
+}
+export function getAstroPaths(repoRoot, dbPathOverride) {
+    const astroRoot = joinRepo(repoRoot, ".astro");
+    const runsDir = joinRepo(repoRoot, ".astro", "runs");
+    const dbPath = dbPathOverride ? joinRepo(repoRoot, dbPathOverride) : joinRepo(repoRoot, ".astro", "astro.db");
+    const specPath = joinRepo(repoRoot, ".astro", "spec.md");
+    const toolOutputDir = joinRepo(repoRoot, ".astro", "tool_output");
+    return {
+        repoRoot,
+        astroRoot,
+        dbPath,
+        runsDir,
+        specPath,
+        toolOutputDir,
+        configPathPreferred: joinRepo(repoRoot, ".astro", "astrocode.config.jsonc"),
+        configPathFallback: joinRepo(repoRoot, "astrocode.config.jsonc"),
+    };
+}
+export function ensureAstroDirs(paths) {
+    ensureDir(paths.astroRoot);
+    ensureDir(paths.runsDir);
+    ensureDir(paths.toolOutputDir);
+}
+export function runDir(paths, runId) {
+    return joinRepo(paths.repoRoot, ".astro", "runs", runId);
+}
+export function stageDir(paths, runId, stageKey) {
+    return joinRepo(paths.repoRoot, ".astro", "runs", runId, stageKey);
+}
+export function assertInsideAstro(repoRoot, filePath) {
+    const absRepo = path.resolve(repoRoot);
+    const abs = path.resolve(filePath);
+    const astroRoot = path.resolve(path.join(repoRoot, ".astro"));
+    if (!abs.startsWith(astroRoot + path.sep) && abs !== astroRoot) {
+        throw new Error(`Refusing to write outside .astro: ${filePath}`);
+    }
+    if (!abs.startsWith(absRepo + path.sep) && abs !== absRepo) {
+        throw new Error(`Refusing to write outside repo root: ${filePath}`);
+    }
+}

package/dist/shared/text.d.ts

@@ -0,0 +1,4 @@
+export declare function normalizeNewlines(s: string): string;
+export declare function clampLines(md: string, maxLines: number): string;
+export declare function clampChars(s: string, maxChars: number): string;
+export declare function stripCodeFences(md: string): string;

package/dist/shared/text.js

@@ -0,0 +1,19 @@
+export function normalizeNewlines(s) {
+    return s.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+export function clampLines(md, maxLines) {
+    const lines = normalizeNewlines(md).split("\n");
+    if (lines.length <= maxLines)
+        return md.trimEnd();
+    return lines.slice(0, maxLines).join("\n").trimEnd() + "\n…";
+}
+export function clampChars(s, maxChars) {
+    if (s.length <= maxChars)
+        return s;
+    return s.slice(0, maxChars) + "\n…(truncated)";
+}
+export function stripCodeFences(md) {
+    // Light helper: remove surrounding triple backticks if present
+    const m = md.match(/^```[a-zA-Z0-9_-]*\n([\s\S]*)\n```\s*$/);
+    return m ? m[1] : md;
+}

package/dist/shared/time.d.ts

@@ -0,0 +1 @@
+export declare function nowISO(): string;

package/dist/shared/time.js

@@ -0,0 +1,3 @@
+export function nowISO() {
+    return new Date().toISOString();
+}

package/dist/state/adapters/index.d.ts

@@ -0,0 +1,39 @@
+export interface DatabaseConnection {
+    pragma(sql: string): void;
+    exec(sql: string): void;
+    prepare(sql: string): Statement;
+    close(): void;
+}
+export interface Statement {
+    run(...params: any[]): {
+        changes: number;
+        lastInsertRowid: any;
+    };
+    get(...params: any[]): any;
+    all(...params: any[]): any[];
+}
+export interface DatabaseAdapter {
+    isAvailable(): boolean;
+    open(path: string, opts?: {
+        busyTimeoutMs?: number;
+    }): DatabaseConnection;
+}
+export declare class MockDatabaseAdapter implements DatabaseAdapter {
+    isAvailable(): boolean;
+    open(): DatabaseConnection;
+}
+export declare class BunSqliteAdapter implements DatabaseAdapter {
+    isAvailable(): boolean;
+    open(path: string, opts?: {
+        busyTimeoutMs?: number;
+    }): DatabaseConnection;
+}
+export declare class BetterSqliteAdapter implements DatabaseAdapter {
+    private Database;
+    constructor();
+    isAvailable(): boolean;
+    open(path: string, opts?: {
+        busyTimeoutMs?: number;
+    }): DatabaseConnection;
+}
+export declare function createDatabaseAdapter(): DatabaseAdapter;

package/dist/state/adapters/index.js

@@ -0,0 +1,119 @@
+import { warn } from "../../shared/log";
+// Mock adapter for when no database is available
+export class MockDatabaseAdapter {
+    isAvailable() {
+        return true; // Mock is always available
+    }
+    open() {
+        warn("Using mock database - no persistence available");
+        return {
+            pragma: () => { },
+            exec: () => { },
+            prepare: () => ({
+                run: () => ({ changes: 0, lastInsertRowid: null }),
+                get: () => null,
+                all: () => []
+            }),
+            close: () => { }
+        };
+    }
+}
+// Bun SQLite adapter - singleton pattern to avoid multiple initializations
+let bunDatabase = null;
+let bunDatabaseInitialized = false;
+function initializeBunDatabase() {
+    if (bunDatabaseInitialized) {
+        return bunDatabase;
+    }
+    bunDatabaseInitialized = true;
+    try {
+        const isBun = typeof globalThis.Bun !== 'undefined';
+        if (isBun) {
+            const { Database } = require('bun:sqlite');
+            bunDatabase = Database;
+        }
+    }
+    catch (e) {
+        // bun:sqlite not available
+    }
+    return bunDatabase;
+}
+// Bun SQLite adapter
+export class BunSqliteAdapter {
+    isAvailable() {
+        return !!initializeBunDatabase();
+    }
+    open(path, opts) {
+        const Database = initializeBunDatabase();
+        if (!Database) {
+            throw new Error("bun:sqlite not available");
+        }
+        const db = new Database(path);
+        // Configure database
+        if (opts?.busyTimeoutMs) {
+            db.exec(`PRAGMA busy_timeout = ${opts.busyTimeoutMs}`);
+        }
+        return {
+            pragma: (sql) => db.exec(`PRAGMA ${sql}`),
+            exec: (sql) => db.exec(sql),
+            prepare: (sql) => {
+                const stmt = db.prepare(sql);
+                return {
+                    run: (...params) => stmt.run(...params),
+                    get: (...params) => stmt.get(...params),
+                    all: (...params) => stmt.all(...params)
+                };
+            },
+            close: () => db.close()
+        };
+    }
+}
+// Better SQLite3 adapter
+export class BetterSqliteAdapter {
+    Database = null;
+    constructor() {
+        try {
+            this.Database = require("better-sqlite3");
+        }
+        catch (e) {
+            // better-sqlite3 not available
+        }
+    }
+    isAvailable() {
+        return !!this.Database;
+    }
+    open(path, opts) {
+        if (!this.Database) {
+            throw new Error("better-sqlite3 not available");
+        }
+        const db = new this.Database(path);
+        // Set busy timeout if specified
+        if (opts?.busyTimeoutMs) {
+            db.pragma(`busy_timeout = ${opts.busyTimeoutMs}`);
+        }
+        return {
+            pragma: (sql) => db.pragma(sql.replace('PRAGMA ', '')),
+            exec: (sql) => db.exec(sql),
+            prepare: (sql) => db.prepare(sql),
+            close: () => db.close()
+        };
+    }
+}
+// Factory function to create the appropriate adapter
+export function createDatabaseAdapter() {
+    const isBun = typeof globalThis.Bun !== 'undefined';
+    if (isBun) {
+        const adapter = new BunSqliteAdapter();
+        if (adapter.isAvailable()) {
+            return adapter;
+        }
+        throw new Error("Bun runtime detected but bun:sqlite not available");
+    }
+    else {
+        const adapter = new BetterSqliteAdapter();
+        if (adapter.isAvailable()) {
+            return adapter;
+        }
+        throw new Error("Node.js runtime detected but better-sqlite3 not available");
+    }
+}

package/dist/state/db.d.ts

@@ -0,0 +1,17 @@
+import { DatabaseConnection } from "./adapters";
+export type SqliteDb = DatabaseConnection;
+export declare function openSqlite(dbPath: string, opts?: {
+    busyTimeoutMs?: number;
+}): SqliteDb;
+export declare function configurePragmas(db: SqliteDb, pragmas: {
+    journal_mode?: "WAL" | "DELETE";
+    synchronous?: "NORMAL" | "FULL" | "OFF";
+    foreign_keys?: boolean;
+    temp_store?: "DEFAULT" | "MEMORY" | "FILE";
+}): void;
+/** BEGIN IMMEDIATE transaction helper. */
+export declare function withTx<T>(db: SqliteDb, fn: () => T): T;
+export declare function ensureSchema(db: SqliteDb, opts?: {
+    allowAutoMigrate?: boolean;
+    failOnDowngrade?: boolean;
+}): void;

package/dist/state/db.js

@@ -0,0 +1,83 @@
+import fs from "node:fs";
+import path from "node:path";
+import { SCHEMA_SQL, SCHEMA_VERSION } from "./schema";
+import { nowISO } from "../shared/time";
+import { createDatabaseAdapter } from "./adapters";
+/** Ensure directory exists for a file path. */
+function ensureParentDir(filePath) {
+    const dir = path.dirname(filePath);
+    fs.mkdirSync(dir, { recursive: true });
+}
+export function openSqlite(dbPath, opts) {
+    ensureParentDir(dbPath);
+    const adapter = createDatabaseAdapter();
+    const db = adapter.open(dbPath, opts);
+    return db;
+}
+export function configurePragmas(db, pragmas) {
+    if (pragmas.journal_mode)
+        db.pragma(`journal_mode = ${pragmas.journal_mode}`);
+    if (pragmas.synchronous)
+        db.pragma(`synchronous = ${pragmas.synchronous}`);
+    if (typeof pragmas.foreign_keys === "boolean")
+        db.pragma(`foreign_keys = ${pragmas.foreign_keys ? "ON" : "OFF"}`);
+    if (pragmas.temp_store)
+        db.pragma(`temp_store = ${pragmas.temp_store}`);
+}
+/** BEGIN IMMEDIATE transaction helper. */
+export function withTx(db, fn) {
+    const adapter = createDatabaseAdapter();
+    if (!adapter.isAvailable()) {
+        // No database available, just run the function
+        return fn();
+    }
+    db.exec("BEGIN IMMEDIATE");
+    try {
+        const out = fn();
+        db.exec("COMMIT");
+        return out;
+    }
+    catch (e) {
+        try {
+            db.exec("ROLLBACK");
+        }
+        catch {
+            // ignore
+        }
+        throw e;
+    }
+}
+export function ensureSchema(db, opts) {
+    const adapter = createDatabaseAdapter();
+    if (!adapter.isAvailable()) {
+        // Silent skip for mock adapter
+        return;
+    }
+    try {
+        db.exec(SCHEMA_SQL);
+        const row = db.prepare("SELECT schema_version FROM repo_state WHERE id = 1").get();
+        if (!row) {
+            const now = nowISO();
+            db.prepare("INSERT INTO repo_state (id, schema_version, created_at, updated_at) VALUES (1, ?, ?, ?)").run(SCHEMA_VERSION, now, now);
+            // Initialize story key seq
+            db.prepare("INSERT OR IGNORE INTO story_keyseq (id, next_story_num) VALUES (1, 1)").run();
+            return;
+        }
+        const currentVersion = row.schema_version ?? 0;
+        if (currentVersion === SCHEMA_VERSION)
+            return;
+        if (currentVersion > SCHEMA_VERSION && (opts?.failOnDowngrade ?? true)) {
+            throw new Error(`Astrocode DB schema_version ${currentVersion} is newer than this plugin (${SCHEMA_VERSION}). Refusing to downgrade.`);
+        }
+        if (currentVersion < SCHEMA_VERSION) {
+            if (!(opts?.allowAutoMigrate ?? true)) {
+                throw new Error(`Astrocode DB schema_version ${currentVersion} is older than required (${SCHEMA_VERSION}). Auto-migrate disabled.`);
+            }
+            // Additive schema: SCHEMA_SQL already created new tables/indexes if missing.
+            db.prepare("UPDATE repo_state SET schema_version = ?, updated_at = ? WHERE id = 1").run(SCHEMA_VERSION, nowISO());
+        }
+    }
+    catch (e) {
+        // Schema operations might fail on mock adapter, silently ignore
+    }
+}

package/dist/state/ids.d.ts

@@ -0,0 +1,8 @@
+export declare function newId(prefix: string): string;
+export declare function newRunId(): string;
+export declare function newStageRunId(): string;
+export declare function newArtifactId(): string;
+export declare function newToolRunId(): string;
+export declare function newEventId(): string;
+export declare function newSnapshotId(): string;
+export declare function newBatchId(): string;

package/dist/state/ids.js

@@ -0,0 +1,25 @@
+import { randomUUID } from "node:crypto";
+export function newId(prefix) {
+    return `${prefix}_${randomUUID()}`;
+}
+export function newRunId() {
+    return newId("run");
+}
+export function newStageRunId() {
+    return newId("stage");
+}
+export function newArtifactId() {
+    return newId("art");
+}
+export function newToolRunId() {
+    return newId("tool");
+}
+export function newEventId() {
+    return newId("evt");
+}
+export function newSnapshotId() {
+    return newId("snap");
+}
+export function newBatchId() {
+    return newId("batch");
+}

package/dist/state/schema.d.ts

@@ -0,0 +1,2 @@
+export declare const SCHEMA_VERSION = 2;
+export declare const SCHEMA_SQL = "\nPRAGMA foreign_keys = ON;\n\nCREATE TABLE IF NOT EXISTS repo_state (\n  id INTEGER PRIMARY KEY CHECK (id = 1),\n  schema_version INTEGER NOT NULL,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  spec_hash_before TEXT,\n  spec_hash_after TEXT,\n  last_run_id TEXT,\n  last_story_key TEXT,\n  last_event_at TEXT\n);\n\nCREATE TABLE IF NOT EXISTS settings (\n  key TEXT PRIMARY KEY,\n  value TEXT NOT NULL,\n  updated_at TEXT NOT NULL\n);\n\nCREATE TABLE IF NOT EXISTS epics (\n  epic_key TEXT PRIMARY KEY,\n  title TEXT NOT NULL,\n  body_md TEXT NOT NULL DEFAULT '',\n  state TEXT NOT NULL DEFAULT 'active',\n  priority INTEGER NOT NULL DEFAULT 0,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL\n);\n\nCREATE TABLE IF NOT EXISTS story_drafts (\n  draft_id TEXT PRIMARY KEY,\n  title TEXT NOT NULL,\n  body_md TEXT NOT NULL DEFAULT '',\n  meta_json TEXT NOT NULL DEFAULT '{}',\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL\n);\n\nCREATE TABLE IF NOT EXISTS story_keyseq (\n  id INTEGER PRIMARY KEY CHECK (id = 1),\n  next_story_num INTEGER NOT NULL\n);\n\nCREATE TABLE IF NOT EXISTS stories (\n  story_key TEXT PRIMARY KEY,\n  epic_key TEXT,\n  title TEXT NOT NULL,\n  body_md TEXT NOT NULL DEFAULT '',\n  state TEXT NOT NULL DEFAULT 'queued', -- queued|approved|in_progress|done|blocked|archived\n  priority INTEGER NOT NULL DEFAULT 0,\n  approved_at TEXT,\n  locked_by_run_id TEXT,\n  locked_at TEXT,\n  in_progress INTEGER NOT NULL DEFAULT 0,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  FOREIGN KEY (epic_key) REFERENCES epics(epic_key)\n);\n\nCREATE TABLE IF NOT EXISTS runs (\n  run_id TEXT PRIMARY KEY,\n  story_key TEXT NOT NULL,\n  status TEXT NOT NULL DEFAULT 'created', -- created|running|completed|failed|aborted\n  pipeline_stages_json TEXT NOT NULL DEFAULT '[]',\n  current_stage_key TEXT,\n  created_at TEXT NOT NULL,\n  started_at TEXT,\n  completed_at TEXT,\n  updated_at TEXT NOT NULL,\n  error_text TEXT,\n  FOREIGN KEY (story_key) REFERENCES stories(story_key)\n);\n\nCREATE TABLE IF NOT EXISTS stage_runs (\n  stage_run_id TEXT PRIMARY KEY,\n  run_id TEXT NOT NULL,\n  stage_key TEXT NOT NULL,\n  stage_index INTEGER NOT NULL,\n  status TEXT NOT NULL DEFAULT 'pending', -- pending|running|completed|failed|skipped\n  subagent_type TEXT,\n  subagent_session_id TEXT,\n  started_at TEXT,\n  completed_at TEXT,\n  updated_at TEXT NOT NULL,\n  baton_path TEXT,\n  summary_md TEXT,\n  output_json TEXT,\n  error_text TEXT,\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE TABLE IF NOT EXISTS artifacts (\n  artifact_id TEXT PRIMARY KEY,\n  run_id TEXT,\n  stage_key TEXT,\n  type TEXT NOT NULL, -- plan|baton|evidence|diff|log|summary|commit|tool_output|snapshot\n  path TEXT NOT NULL,\n  sha256 TEXT,\n  meta_json TEXT NOT NULL DEFAULT '{}',\n  created_at TEXT NOT NULL,\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE TABLE IF NOT EXISTS tool_runs (\n  tool_run_id TEXT PRIMARY KEY,\n  run_id TEXT,\n  stage_key TEXT,\n  tool_name TEXT NOT NULL,\n  args_json TEXT NOT NULL DEFAULT '{}',\n  output_summary TEXT NOT NULL DEFAULT '',\n  output_artifact_id TEXT,\n  created_at TEXT NOT NULL,\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE TABLE IF NOT EXISTS events (\n  event_id TEXT PRIMARY KEY,\n  run_id TEXT,\n  stage_key TEXT,\n  type TEXT NOT NULL,\n  body_json TEXT NOT NULL DEFAULT '{}',\n  created_at TEXT NOT NULL,\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE TABLE IF NOT EXISTS injects (\n  inject_id TEXT PRIMARY KEY,\n  type TEXT NOT NULL DEFAULT 'note',\n  title TEXT NOT NULL,\n  body_md TEXT NOT NULL,\n  tags_json TEXT NOT NULL DEFAULT '[]',\n  scope TEXT NOT NULL DEFAULT 'repo', -- repo|run:<id>|story:<key>|global\n  source TEXT NOT NULL DEFAULT 'user', -- user|tool|agent|import\n  priority INTEGER NOT NULL DEFAULT 50,\n  expires_at TEXT,\n  sha256 TEXT,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL\n);\n\nCREATE TABLE IF NOT EXISTS running_batches (\n  batch_id TEXT PRIMARY KEY,\n  run_id TEXT,\n  session_id TEXT,\n  status TEXT NOT NULL DEFAULT 'running', -- running|completed|failed|aborted\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE TABLE IF NOT EXISTS workflow_metrics (\n  metric_id TEXT PRIMARY KEY,\n  run_id TEXT,\n  stage_key TEXT,\n  name TEXT NOT NULL,\n  value_num REAL,\n  value_text TEXT,\n  created_at TEXT NOT NULL,\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE TABLE IF NOT EXISTS template_intents (\n  intent_key TEXT PRIMARY KEY,\n  body_md TEXT NOT NULL,\n  updated_at TEXT NOT NULL\n);\n\n-- vNext tables\n\nCREATE TABLE IF NOT EXISTS story_relations (\n  parent_story_key TEXT NOT NULL,\n  child_story_key TEXT NOT NULL,\n  relation_type TEXT NOT NULL DEFAULT 'split',\n  reason TEXT NOT NULL DEFAULT '',\n  created_at TEXT NOT NULL,\n  PRIMARY KEY (parent_story_key, child_story_key),\n  FOREIGN KEY (parent_story_key) REFERENCES stories(story_key),\n  FOREIGN KEY (child_story_key) REFERENCES stories(story_key)\n);\n\nCREATE TABLE IF NOT EXISTS continuations (\n  continuation_id INTEGER PRIMARY KEY AUTOINCREMENT,\n  session_id TEXT NOT NULL,\n  run_id TEXT,\n  directive_hash TEXT NOT NULL,\n  kind TEXT NOT NULL, -- continue|stage|blocked|repair\n  reason TEXT NOT NULL DEFAULT '',\n  created_at TEXT NOT NULL,\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE INDEX IF NOT EXISTS idx_continuations_session_created ON continuations(session_id, created_at DESC);\nCREATE INDEX IF NOT EXISTS idx_continuations_run_created ON continuations(run_id, created_at DESC);\n\nCREATE TABLE IF NOT EXISTS context_snapshots (\n  snapshot_id TEXT PRIMARY KEY,\n  run_id TEXT NOT NULL,\n  stage_key TEXT NOT NULL,\n  summary_md TEXT NOT NULL,\n  created_at TEXT NOT NULL,\n  FOREIGN KEY (run_id) REFERENCES runs(run_id)\n);\n\nCREATE INDEX IF NOT EXISTS idx_context_snapshots_run_created ON context_snapshots(run_id, created_at DESC);\n\nCREATE TABLE IF NOT EXISTS agent_sessions (\n  session_id TEXT PRIMARY KEY,\n  parent_session_id TEXT,\n  agent_name TEXT NOT NULL,\n  run_id TEXT,\n  stage_key TEXT,\n  status TEXT NOT NULL DEFAULT 'active',\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL\n);\n\n-- Indexes\n\nCREATE INDEX IF NOT EXISTS idx_stories_state ON stories(state);\nCREATE INDEX IF NOT EXISTS idx_runs_story ON runs(story_key);\nCREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status);\nCREATE INDEX IF NOT EXISTS idx_stage_runs_run ON stage_runs(run_id, stage_index);\nCREATE INDEX IF NOT EXISTS idx_artifacts_run_stage ON artifacts(run_id, stage_key, created_at DESC);\nCREATE INDEX IF NOT EXISTS idx_events_run ON events(run_id, created_at DESC);\nCREATE INDEX IF NOT EXISTS idx_tool_runs_run ON tool_runs(run_id, created_at DESC);\nCREATE INDEX IF NOT EXISTS idx_injects_scope_priority ON injects(scope, priority DESC, created_at DESC);\n\n-- Stronger invariants (SQLite partial indexes)\n-- Only one run may be 'running' at a time (single-repo harness by default).\nCREATE UNIQUE INDEX IF NOT EXISTS uniq_single_running_run\n  ON runs(status)\n  WHERE status = 'running';\n\n-- Only one story may be in_progress=1 at a time (pairs with single running run).\nCREATE UNIQUE INDEX IF NOT EXISTS uniq_single_in_progress_story\n  ON stories(in_progress)\n  WHERE in_progress = 1;\n\n";