astrocode-workflow 0.0.1

package/src/state/schema.ts

@@ -0,0 +1,249 @@
+// 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/src/state/types.ts

@@ -0,0 +1,76 @@
+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/src/tools/artifacts.ts

@@ -0,0 +1,83 @@
+import fs from "node:fs";
+import path from "node:path";
+import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+import { getAstroPaths } from "../shared/paths";
+import { putArtifact, listArtifacts, getArtifact } from "../workflow/artifacts";
+
+export function createAstroArtifactPutTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
+  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 as string;
+      const meta = JSON.parse(meta_json || "{}") as Record<string, unknown>;
+
+      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: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
+  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: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
+  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 as string;
+      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/src/tools/index.ts

@@ -0,0 +1,111 @@
+import type { ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+
+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: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): Record<string, ToolDefinition> {
+  const { ctx, config, db } = opts;
+  const hasDatabase = !!db;
+
+  const tools: Record<string, ToolDefinition> = {};
+
+  // 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: Array<[string, string]> = [
+    ["_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/src/tools/init.ts

@@ -0,0 +1,50 @@
+import fs from "node:fs";
+import path from "node:path";
+import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+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: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
+  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 as string;
+      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() as any;
+
+      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/src/tools/injects.ts

@@ -0,0 +1,108 @@
+import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+import { nowISO } from "../shared/time";
+import { sha256Hex } from "../shared/hash";
+
+function newInjectId(): string {
+  return `inj_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+}
+
+export function createAstroInjectPutTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
+  const { db } = opts;
+
+  return tool({
+    description: "Create/update an inject (note/policy) stored in the DB. Useful for persistent rules.",
+    args: {
+      inject_id: tool.schema.string().optional(),
+      type: tool.schema.string().default("note"),
+      title: tool.schema.string().min(1),
+      body_md: tool.schema.string().min(1),
+      tags_json: tool.schema.string().default("[]"),
+      scope: tool.schema.string().default("repo"),
+      source: tool.schema.string().default("user"),
+      priority: tool.schema.number().int().default(50),
+      expires_at: tool.schema.string().nullable().optional(),
+    },
+    execute: async ({ inject_id, type, title, body_md, tags_json, scope, source, priority, expires_at }) => {
+      const id = inject_id ?? newInjectId();
+      const now = nowISO();
+      const sha = sha256Hex(body_md);
+
+      const existing = db.prepare("SELECT inject_id FROM injects WHERE inject_id=?").get(id) as any;
+
+      if (existing) {
+        db.prepare(
+          "UPDATE injects SET type=?, title=?, body_md=?, tags_json=?, scope=?, source=?, priority=?, expires_at=?, sha256=?, updated_at=? WHERE inject_id=?"
+        ).run(type, title, body_md, tags_json, scope, source, priority, expires_at ?? null, sha, now, id);
+        return `✅ Updated inject ${id}: ${title}`;
+      }
+
+      db.prepare(
+        "INSERT INTO injects (inject_id, type, title, body_md, tags_json, scope, source, priority, expires_at, sha256, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
+      ).run(id, type, title, body_md, tags_json, scope, source, priority, expires_at ?? null, sha, now, now);
+
+      return `✅ Created inject ${id}: ${title}`;
+    },
+  });
+}
+
+export function createAstroInjectListTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
+  const { db } = opts;
+
+  return tool({
+    description: "List injects (optionally filtered by scope/type).",
+    args: {
+      scope: tool.schema.string().optional(),
+      type: tool.schema.string().optional(),
+      limit: tool.schema.number().int().positive().default(50),
+    },
+    execute: async ({ scope, type, limit }) => {
+      const where: string[] = [];
+      const params: any[] = [];
+      if (scope) { where.push("scope = ?"); params.push(scope); }
+      if (type) { where.push("type = ?"); params.push(type); }
+      const sql = `SELECT inject_id, type, title, scope, priority, created_at, updated_at FROM injects ${where.length ? "WHERE " + where.join(" AND ") : ""} ORDER BY priority DESC, updated_at DESC LIMIT ?`;
+      const rows = db.prepare(sql).all(...params, limit) as any[];
+      return JSON.stringify(rows, null, 2);
+    },
+  });
+}
+
+export function createAstroInjectGetTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
+  const { db } = opts;
+
+  return tool({
+    description: "Get an inject by id (full body).",
+    args: {
+      inject_id: tool.schema.string().min(1),
+    },
+    execute: async ({ inject_id }) => {
+      const row = db.prepare("SELECT * FROM injects WHERE inject_id=?").get(inject_id) as any;
+      if (!row) throw new Error(`Inject not found: ${inject_id}`);
+      return JSON.stringify(row, null, 2);
+    },
+  });
+}
+
+export function createAstroInjectSearchTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
+  const { db } = opts;
+
+  return tool({
+    description: "Search injects by query substring over title/body/tags. Returns matches ordered by priority/recency.",
+    args: {
+      q: tool.schema.string().min(1),
+      scope: tool.schema.string().optional(),
+      limit: tool.schema.number().int().positive().default(20),
+    },
+    execute: async ({ q, scope, limit }) => {
+      const like = `%${q}%`;
+      const where: string[] = ["(title LIKE ? OR body_md LIKE ? OR tags_json LIKE ?)"];
+      const params: any[] = [like, like, like];
+      if (scope) { where.push("scope = ?"); params.push(scope); }
+      const sql = `SELECT inject_id, type, title, scope, priority, updated_at FROM injects WHERE ${where.join(" AND ")} ORDER BY priority DESC, updated_at DESC LIMIT ?`;
+      const rows = db.prepare(sql).all(...params, limit) as any[];
+      return JSON.stringify(rows, null, 2);
+    },
+  });
+}