astrocode-workflow 0.0.1

package/dist/state/schema.js

@@ -0,0 +1,247 @@
+// 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
+  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);
+
+-- 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/state/types.d.ts

@@ -0,0 +1,70 @@
+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;
+    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/state/types.js

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

package/dist/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/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/tools/index.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 createAstroTools(opts: {
+    ctx: any;
+    config: AstrocodeConfig;
+    db: SqliteDb;
+}): Record<string, ToolDefinition>;

package/dist/tools/index.js

@@ -0,0 +1,100 @@
+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 } from "./injects";
+import { createAstroRepairTool } from "./repair";
+export function createAstroTools(opts) {
+    const { ctx, config, db } = opts;
+    const hasDatabase = !!db;
+    const tools = {};
+    // Always available tools
+    tools.astro_status = createAstroStatusTool({ ctx, config, db });
+    // Always available tools (work without database)
+    tools.astro_status = createAstroStatusTool({ ctx, config, db });
+    tools.astro_spec_get = createAstroSpecGetTool({ ctx, config, db });
+    // Database-dependent tools
+    if (hasDatabase) {
+        tools.astro_init = createAstroInitTool({ ctx, config, db });
+        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 });
+        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_repair = createAstroRepairTool({ ctx, config, db });
+    }
+    else {
+        // Limited mode tools - provide helpful messages instead of failing
+        tools.astro_init = {
+            description: "Initialize Astrocode (requires database - currently unavailable)",
+            args: {},
+            execute: async () => "❌ Database not available. Astrocode is running in limited mode."
+        };
+        tools.astro_story_queue = {
+            description: "Queue a story (requires database - currently unavailable)",
+            args: {},
+            execute: async () => "❌ Database not available. Astrocode is running in limited mode."
+        };
+        tools.astro_spec_set = {
+            description: "Set project spec (requires database for hash tracking - currently unavailable)",
+            args: {},
+            execute: async () => "❌ Database not available. Astrocode is running in limited mode."
+        };
+        tools.astro_workflow_proceed = {
+            description: "Advance workflow (requires database - currently unavailable)",
+            args: {},
+            execute: async () => "❌ Database not available. Astrocode is running in limited mode."
+        };
+    }
+    // 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_repair", "astro_repair"],
+    ];
+    // Only add aliases for tools that exist
+    for (const [alias, target] of aliases) {
+        if (tools[target]) {
+            tools[alias] = tools[target];
+        }
+    }
+    return tools;
+}

package/dist/tools/init.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 createAstroInitTool(opts: {
+    ctx: any;
+    config: AstrocodeConfig;
+    db: SqliteDb;
+}): ToolDefinition;

package/dist/tools/init.js

@@ -0,0 +1,41 @@
+import fs from "node:fs";
+import path from "node:path";
+import { tool } from "@opencode-ai/plugin/tool";
+import { ensureSchema } from "../state/db";
+import { getAstroPaths, ensureAstroDirs } from "../shared/paths";
+import { nowISO } from "../shared/time";
+import { sha256Hex } from "../shared/hash";
+export function createAstroInitTool(opts) {
+    const { ctx, config, db } = opts;
+    return tool({
+        description: "Initialize Astrocode vNext in this repo: create .astro directories, ensure SQLite schema, and create a placeholder spec if missing. Idempotent.",
+        args: {
+            ensure_spec: tool.schema.boolean().default(true),
+            spec_placeholder: tool.schema.string().default("# Project Spec\n\n(Write the spec here.)\n"),
+        },
+        execute: async ({ ensure_spec, spec_placeholder }) => {
+            const repoRoot = ctx.directory;
+            const paths = getAstroPaths(repoRoot, config.db.path);
+            ensureAstroDirs(paths);
+            ensureSchema(db, { allowAutoMigrate: config.db.allow_auto_migrate, failOnDowngrade: config.db.fail_on_downgrade });
+            if (ensure_spec) {
+                if (!fs.existsSync(paths.specPath)) {
+                    fs.writeFileSync(paths.specPath, spec_placeholder);
+                    const specHash = sha256Hex(spec_placeholder);
+                    const now = nowISO();
+                    db.prepare("UPDATE repo_state SET spec_hash_after=?, updated_at=? WHERE id=1").run(specHash, now);
+                }
+            }
+            const stat = db.prepare("SELECT schema_version, created_at, updated_at FROM repo_state WHERE id=1").get();
+            return [
+                `✅ Astrocode initialized.`,
+                ``,
+                `- Repo: ${repoRoot}`,
+                `- DB: ${path.relative(repoRoot, paths.dbPath)} (schema_version=${stat?.schema_version ?? "?"})`,
+                `- Spec: ${path.relative(repoRoot, paths.specPath)}`,
+                ``,
+                `Next: queue a story (astro_story_queue) and approve it (astro_story_approve), or run /astro-status.`,
+            ].join("\n");
+        },
+    });
+}

package/dist/tools/injects.d.ts

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