astrocode-workflow 0.3.0 → 0.3.2

package/dist/src/state/schema.js

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

package/dist/src/state/types.d.ts

@@ -0,0 +1,71 @@
+export type StoryState = "queued" | "approved" | "in_progress" | "done" | "blocked" | "archived";
+export type RunStatus = "created" | "running" | "completed" | "failed" | "aborted";
+export type StageStatus = "pending" | "running" | "completed" | "failed" | "skipped";
+export type StageKey = "frame" | "plan" | "spec" | "implement" | "review" | "verify" | "close";
+export type StoryRow = {
+    story_key: string;
+    epic_key: string | null;
+    title: string;
+    body_md: string;
+    state: StoryState;
+    priority: number;
+    approved_at: string | null;
+    locked_by_run_id: string | null;
+    locked_at: string | null;
+    in_progress: 0 | 1;
+    created_at: string;
+    updated_at: string;
+};
+export type RunRow = {
+    run_id: string;
+    story_key: string;
+    status: RunStatus;
+    pipeline_stages_json: string;
+    current_stage_key: string | null;
+    created_at: string;
+    started_at: string | null;
+    completed_at: string | null;
+    updated_at: string;
+    error_text: string | null;
+};
+export type StageRunRow = {
+    stage_run_id: string;
+    run_id: string;
+    stage_key: StageKey;
+    stage_index: number;
+    status: StageStatus;
+    created_at: string;
+    subagent_type: string | null;
+    subagent_session_id: string | null;
+    started_at: string | null;
+    completed_at: string | null;
+    updated_at: string;
+    baton_path: string | null;
+    summary_md: string | null;
+    output_json: string | null;
+    error_text: string | null;
+};
+export type ArtifactRow = {
+    artifact_id: string;
+    run_id: string | null;
+    stage_key: string | null;
+    type: string;
+    path: string;
+    sha256: string | null;
+    meta_json: string;
+    created_at: string;
+};
+export type InjectRow = {
+    inject_id: string;
+    type: string;
+    title: string;
+    body_md: string;
+    tags_json: string;
+    scope: string;
+    source: string;
+    priority: number;
+    expires_at: string | null;
+    sha256: string | null;
+    created_at: string;
+    updated_at: string;
+};

package/dist/src/state/types.js

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

package/dist/src/tools/artifacts.d.ts

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

package/dist/src/tools/artifacts.js

@@ -0,0 +1,71 @@
+import fs from "node:fs";
+import path from "node:path";
+import { tool } from "@opencode-ai/plugin/tool";
+import { putArtifact, listArtifacts, getArtifact } from "../workflow/artifacts";
+export function createAstroArtifactPutTool(opts) {
+    const { ctx, db } = opts;
+    return tool({
+        description: "Write an artifact file under .astro and record it in the DB.",
+        args: {
+            run_id: tool.schema.string().nullable().optional(),
+            stage_key: tool.schema.string().nullable().optional(),
+            type: tool.schema.string().default("log"),
+            rel_path: tool.schema.string().min(1),
+            content: tool.schema.string().default(""),
+            meta_json: tool.schema.string().default("{}"),
+        },
+        execute: async ({ run_id, stage_key, type, rel_path, content, meta_json }) => {
+            const repoRoot = ctx.directory;
+            const meta = JSON.parse(meta_json || "{}");
+            const res = putArtifact({
+                repoRoot,
+                db,
+                run_id: run_id ?? null,
+                stage_key: stage_key ?? null,
+                type,
+                rel_path,
+                content,
+                meta,
+            });
+            return `✅ Wrote artifact ${res.artifact_id} (${type}) at ${rel_path} (sha256=${res.sha256})`;
+        },
+    });
+}
+export function createAstroArtifactListTool(opts) {
+    const { db } = opts;
+    return tool({
+        description: "List artifacts (optionally filtered by run_id, stage_key, type).",
+        args: {
+            run_id: tool.schema.string().optional(),
+            stage_key: tool.schema.string().optional(),
+            type: tool.schema.string().optional(),
+        },
+        execute: async ({ run_id, stage_key, type }) => {
+            const rows = listArtifacts(db, { run_id, stage_key, type });
+            return JSON.stringify(rows, null, 2);
+        },
+    });
+}
+export function createAstroArtifactGetTool(opts) {
+    const { ctx, config, db } = opts;
+    return tool({
+        description: "Get artifact metadata (and optionally file contents).",
+        args: {
+            artifact_id: tool.schema.string().min(1),
+            include_body: tool.schema.boolean().default(false),
+            max_body_chars: tool.schema.number().int().positive().default(50_000),
+        },
+        execute: async ({ artifact_id, include_body, max_body_chars }) => {
+            const row = getArtifact(db, artifact_id);
+            if (!row)
+                throw new Error(`Artifact not found: ${artifact_id}`);
+            if (!include_body)
+                return JSON.stringify(row, null, 2);
+            const repoRoot = ctx.directory;
+            const abs = path.join(repoRoot, row.path);
+            const body = fs.existsSync(abs) ? fs.readFileSync(abs, "utf-8") : "(missing file)";
+            const clipped = body.length > max_body_chars ? body.slice(0, max_body_chars) + "\n…(truncated)" : body;
+            return JSON.stringify({ ...row, body: clipped }, null, 2);
+        },
+    });
+}

package/dist/src/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;

package/dist/src/tools/health.js

@@ -0,0 +1,119 @@
+// src/tools/health.ts
+import { tool } from "@opencode-ai/plugin/tool";
+import { getSchemaVersion } from "../state/db";
+import { getActiveRun } from "../workflow/state-machine";
+import fs from "node:fs";
+import path from "node:path";
+export function createAstroHealthTool(opts) {
+    const { ctx, config, db } = opts;
+    return tool({
+        description: "Check Astrocode health: DB status, locks, schema, active runs, recent events.",
+        args: {},
+        execute: async () => {
+            const lines = [];
+            const repoRoot = ctx.directory || process.cwd();
+            const dbPath = config.db?.path || ".astro/astro.db";
+            const fullDbPath = path.resolve(repoRoot, dbPath);
+            // System info
+            lines.push("# Astrocode Health Check");
+            lines.push(`- PID: ${process.pid || "unknown"}`);
+            lines.push(`- Repo: ${repoRoot}`);
+            lines.push(`- DB Path: ${fullDbPath}`);
+            // Lock status
+            const lockPath = `${repoRoot}/.astro/astro.lock`;
+            try {
+                if (fs.existsSync(lockPath)) {
+                    const lockContent = fs.readFileSync(lockPath, "utf8").trim();
+                    const parts = lockContent.split(" ");
+                    if (parts.length >= 2) {
+                        const pid = parseInt(parts[0]);
+                        const startedAt = parts[1];
+                        // Check if PID is still running
+                        try {
+                            process.kill(pid, 0); // Signal 0 just checks if process exists
+                            lines.push(`- Lock: HELD by PID ${pid} (started ${startedAt})`);
+                        }
+                        catch {
+                            lines.push(`- Lock: STALE (PID ${pid} not running, started ${startedAt})`);
+                            lines.push(`  → Run: rm "${lockPath}"`);
+                        }
+                    }
+                    else {
+                        lines.push(`- Lock: MALFORMED (${lockContent})`);
+                    }
+                }
+                else {
+                    lines.push(`- Lock: NONE (no lock file)`);
+                }
+            }
+            catch (e) {
+                lines.push(`- Lock: ERROR (${String(e)})`);
+            }
+            // DB file status
+            const dbExists = fs.existsSync(fullDbPath);
+            const walExists = fs.existsSync(`${fullDbPath}-wal`);
+            const shmExists = fs.existsSync(`${fullDbPath}-shm`);
+            lines.push(`- DB Files:`);
+            lines.push(`  - Main: ${dbExists ? "EXISTS" : "MISSING"}`);
+            lines.push(`  - WAL: ${walExists ? "EXISTS" : "MISSING"}`);
+            lines.push(`  - SHM: ${shmExists ? "EXISTS" : "MISSING"}`);
+            if (!dbExists) {
+                lines.push(`- STATUS: DB MISSING - run astro_init first`);
+                return lines.join("\n");
+            }
+            // Schema version
+            try {
+                const schemaVersion = getSchemaVersion(db);
+                lines.push(`- Schema Version: ${schemaVersion}`);
+            }
+            catch (e) {
+                lines.push(`- Schema Version: ERROR (${String(e)})`);
+                lines.push(`- STATUS: DB CORRUPTED`);
+                return lines.join("\n");
+            }
+            // Active run
+            try {
+                const activeRun = getActiveRun(db);
+                if (activeRun) {
+                    lines.push(`- Active Run: ${activeRun.run_id} (${activeRun.status})`);
+                    lines.push(`  - Story: ${activeRun.story_key}`);
+                    lines.push(`  - Stage: ${activeRun.current_stage_key || "none"}`);
+                    lines.push(`  - Started: ${activeRun.started_at}`);
+                }
+                else {
+                    lines.push(`- Active Run: NONE`);
+                }
+            }
+            catch (e) {
+                lines.push(`- Active Run: ERROR (${String(e)})`);
+            }
+            // Recent events
+            try {
+                const events = db.prepare(`
+          SELECT event_id, run_id, stage_key, type, created_at
+          FROM events
+          ORDER BY created_at DESC
+          LIMIT 10
+        `).all();
+                lines.push(`- Recent Events (${events.length}):`);
+                for (const event of events) {
+                    const stage = event.stage_key ? `/${event.stage_key}` : "";
+                    lines.push(`  - ${event.created_at}: ${event.type} (${event.run_id || "global"}${stage})`);
+                }
+            }
+            catch (e) {
+                lines.push(`- Recent Events: ERROR (${String(e)})`);
+            }
+            // Status summary
+            lines.push(``);
+            lines.push(`## Status`);
+            lines.push(`✅ DB accessible`);
+            lines.push(`✅ Schema valid`);
+            lines.push(`✅ Lock file checked`);
+            if (walExists || shmExists) {
+                lines.push(`⚠️ WAL/SHM files present - indicates unclean shutdown or active transaction`);
+            }
+            return lines.join("\n");
+        },
+    });
+}

package/dist/src/tools/index.d.ts

@@ -0,0 +1,20 @@
+import type { ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+import { AgentConfig } from "@opencode-ai/sdk";
+type RuntimeState = {
+    db: SqliteDb | null;
+    limitedMode: boolean;
+    limitedModeReason: null | {
+        code: "db_init_failed" | "schema_too_old" | "schema_downgrade" | "schema_migration_failed";
+        details: any;
+    };
+};
+type CreateAstroToolsOptions = {
+    ctx: any;
+    config: AstrocodeConfig;
+    agents?: Record<string, AgentConfig>;
+    runtime: RuntimeState;
+};
+export declare function createAstroTools(opts: CreateAstroToolsOptions): Record<string, ToolDefinition>;
+export {};

package/dist/src/tools/index.js

@@ -0,0 +1,94 @@
+import { createAstroInitTool } from "./init";
+import { createAstroStatusTool } from "./status";
+import { createAstroStoryQueueTool, createAstroStoryApproveTool, createAstroStoryBoardTool, createAstroStorySetStateTool } from "./story";
+import { createAstroSpecGetTool, createAstroSpecSetTool } from "./spec";
+import { createAstroRunGetTool, createAstroRunAbortTool } from "./run";
+import { createAstroWorkflowProceedTool } from "./workflow";
+import { createAstroStageStartTool, createAstroStageCompleteTool, createAstroStageFailTool, createAstroStageResetTool } from "./stage";
+import { createAstroArtifactPutTool, createAstroArtifactListTool, createAstroArtifactGetTool } from "./artifacts";
+import { createAstroInjectPutTool, createAstroInjectListTool, createAstroInjectSearchTool, createAstroInjectGetTool, createAstroInjectEligibleTool, createAstroInjectDebugDueTool } from "./injects";
+import { createAstroRepairTool } from "./repair";
+import { createAstroHealthTool } from "./health";
+import { createAstroResetTool } from "./reset";
+import { createAstroMetricsTool } from "./metrics";
+export function createAstroTools(opts) {
+    const { ctx, config, agents, runtime } = opts;
+    const { db } = runtime;
+    const hasDatabase = db !== null; // Source of truth: DB availability
+    const tools = {};
+    // Always available tools (work without database - guaranteed DB-independent)
+    tools.astro_status = createAstroStatusTool({ ctx, config });
+    tools.astro_spec_get = createAstroSpecGetTool({ ctx, config });
+    tools.astro_health = createAstroHealthTool({ ctx, config, db });
+    tools.astro_reset = createAstroResetTool({ ctx, config, db });
+    tools.astro_metrics = createAstroMetricsTool({ ctx, config });
+    // Recovery tool - available even in limited mode to allow DB initialization
+    tools.astro_init = createAstroInitTool({ ctx, config, runtime });
+    // Database-dependent tools
+    if (hasDatabase) {
+        // Ensure agents are available for workflow tools that require them
+        if (!agents) {
+            throw new Error("astro_workflow_proceed requires agents to be provided in normal mode.");
+        }
+        tools.astro_story_queue = createAstroStoryQueueTool({ ctx, config, db });
+        tools.astro_story_approve = createAstroStoryApproveTool({ ctx, config, db });
+        tools.astro_story_board = createAstroStoryBoardTool({ ctx, config, db });
+        tools.astro_story_set_state = createAstroStorySetStateTool({ ctx, config, db });
+        tools.astro_spec_set = createAstroSpecSetTool({ ctx, config, db });
+        tools.astro_run_get = createAstroRunGetTool({ ctx, config, db });
+        tools.astro_run_abort = createAstroRunAbortTool({ ctx, config, db });
+        tools.astro_workflow_proceed = createAstroWorkflowProceedTool({ ctx, config, db, agents });
+        tools.astro_stage_start = createAstroStageStartTool({ ctx, config, db });
+        tools.astro_stage_complete = createAstroStageCompleteTool({ ctx, config, db });
+        tools.astro_stage_fail = createAstroStageFailTool({ ctx, config, db });
+        tools.astro_stage_reset = createAstroStageResetTool({ ctx, config, db });
+        tools.astro_artifact_put = createAstroArtifactPutTool({ ctx, config, db });
+        tools.astro_artifact_list = createAstroArtifactListTool({ ctx, config, db });
+        tools.astro_artifact_get = createAstroArtifactGetTool({ ctx, config, db });
+        tools.astro_inject_put = createAstroInjectPutTool({ ctx, config, db });
+        tools.astro_inject_list = createAstroInjectListTool({ ctx, config, db });
+        tools.astro_inject_search = createAstroInjectSearchTool({ ctx, config, db });
+        tools.astro_inject_get = createAstroInjectGetTool({ ctx, config, db });
+        tools.astro_inject_eligible = createAstroInjectEligibleTool({ ctx, config, db });
+        tools.astro_inject_debug_due = createAstroInjectDebugDueTool({ ctx, config, db });
+        tools.astro_repair = createAstroRepairTool({ ctx, config, db });
+    }
+    // Create aliases for backward compatibility
+    const aliases = [
+        ["_astro_init", "astro_init"],
+        ["_astro_status", "astro_status"],
+        ["_astro_story_queue", "astro_story_queue"],
+        ["_astro_story_approve", "astro_story_approve"],
+        ["_astro_story_board", "astro_story_board"],
+        ["_astro_story_set_state", "astro_story_set_state"],
+        ["_astro_spec_get", "astro_spec_get"],
+        ["_astro_spec_set", "astro_spec_set"],
+        ["_astro_run_get", "astro_run_get"],
+        ["_astro_run_abort", "astro_run_abort"],
+        ["_astro_workflow_proceed", "astro_workflow_proceed"],
+        ["_astro_stage_start", "astro_stage_start"],
+        ["_astro_stage_complete", "astro_stage_complete"],
+        ["_astro_stage_fail", "astro_stage_fail"],
+        ["_astro_stage_reset", "astro_stage_reset"],
+        ["_astro_artifact_put", "astro_artifact_put"],
+        ["_astro_artifact_list", "astro_artifact_list"],
+        ["_astro_artifact_get", "astro_artifact_get"],
+        ["_astro_inject_put", "astro_inject_put"],
+        ["_astro_inject_list", "astro_inject_list"],
+        ["_astro_inject_search", "astro_inject_search"],
+        ["_astro_inject_get", "astro_inject_get"],
+        ["_astro_inject_eligible", "astro_inject_eligible"],
+        ["_astro_inject_debug_due", "astro_inject_debug_due"],
+        ["_astro_repair", "astro_repair"],
+        ["_astro_health", "astro_health"],
+        ["_astro_reset", "astro_reset"],
+        ["_astro_metrics", "astro_metrics"],
+    ];
+    // Only add aliases for tools that exist
+    for (const [alias, target] of aliases) {
+        if (tools[target]) {
+            tools[alias] = tools[target];
+        }
+    }
+    return tools;
+}

package/dist/src/tools/init.d.ts

@@ -0,0 +1,17 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+type RuntimeState = {
+    db: SqliteDb | null;
+    limitedMode: boolean;
+    limitedModeReason: null | {
+        code: "db_init_failed" | "schema_too_old" | "schema_downgrade" | "schema_migration_failed";
+        details: any;
+    };
+};
+export declare function createAstroInitTool(opts: {
+    ctx: any;
+    config: AstrocodeConfig;
+    runtime: RuntimeState;
+}): ToolDefinition;
+export {};