astrocode-workflow 0.4.5 → 0.4.6

package/dist/src/hooks/continuation-enforcer.d.ts

@@ -1,5 +1,5 @@
 import type { AstrocodeConfig } from "../config/schema";
-import type { SqliteDb } from "../state/db";
+import type { RuntimeState } from "../state/types";
 type ToolExecuteAfterInput = {
     tool: string;
     sessionID?: string;
@@ -14,14 +14,6 @@ type EventInput = {
         properties: any;
     };
 };
-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 createContinuationEnforcer(opts: {
     ctx: any;
     config: AstrocodeConfig;

package/dist/src/hooks/continuation-enforcer.js

@@ -10,7 +10,6 @@ function msFromIso(iso) {
 }
 export function createContinuationEnforcer(opts) {
     const { ctx, config, runtime } = opts;
-    const { db } = runtime;
     const toasts = createToastManager({ ctx, throttleMs: config.ui.toasts.throttle_ms });
     const sessions = new Map();
     function getState(sessionId) {
@@ -61,6 +60,9 @@ export function createContinuationEnforcer(opts) {
         }, interval);
     }
     function shouldDedupe(sessionId, directive) {
+        const { db } = runtime;
+        if (!db)
+            return false;
         const s = getState(sessionId);
         const now = Date.now();
         // Memory window
@@ -78,6 +80,9 @@ export function createContinuationEnforcer(opts) {
         return false;
     }
     async function recordContinuation(sessionId, runId, directive, reason) {
+        const { db } = runtime;
+        if (!db)
+            return;
         db.prepare("INSERT INTO continuations (session_id, run_id, directive_hash, kind, reason, created_at) VALUES (?, ?, ?, ?, ?, ?)").run(sessionId, runId, directive.hash, directive.kind, reason, nowISO());
         const s = getState(sessionId);
         const now = Date.now();
@@ -109,7 +114,8 @@ export function createContinuationEnforcer(opts) {
         }
     }
     async function maybeInjectContinue(sessionId, reason) {
-        if (!config.continuation.enabled)
+        const { db } = runtime;
+        if (!config.continuation.enabled || !db)
             return;
         // Require active run
         const active = getActiveRun(db);
@@ -154,6 +160,8 @@ export function createContinuationEnforcer(opts) {
             const sessionId = input.sessionID ?? ctx.sessionID;
             if (!sessionId)
                 return;
+            if (!config.continuation.enabled)
+                return;
             if (!config.continuation.inject_on_tool_done_if_run_active)
                 return;
             // Inject continuation immediately after any tool execution
@@ -161,6 +169,8 @@ export function createContinuationEnforcer(opts) {
             scheduleIdleInjection(sessionId);
         },
         async onChatMessage(_input) {
+            if (!config.continuation.enabled)
+                return;
             if (!config.continuation.inject_on_message_done_if_run_active)
                 return;
             scheduleIdleInjection(_input.sessionID);

package/dist/src/hooks/inject-provider.d.ts

@@ -1,5 +1,5 @@
 import type { AstrocodeConfig } from "../config/schema";
-import type { SqliteDb } from "../state/db";
+import type { RuntimeState } from "../state/types";
 type ChatMessageInput = {
     sessionID: string;
     agent: string;
@@ -8,14 +8,6 @@ type ToolExecuteAfterInput = {
     tool: string;
     sessionID?: string;
 };
-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 createInjectProvider(opts: {
     ctx: any;
     config: AstrocodeConfig;

package/dist/src/hooks/inject-provider.js

@@ -4,7 +4,6 @@ import { nowISO } from "../shared/time";
 import { getActiveRun } from "../workflow/state-machine";
 export function createInjectProvider(opts) {
     const { ctx, config, runtime } = opts;
-    const { db } = runtime;
     // Cache to avoid re-injecting the same injects repeatedly
     // Map of inject_id -> last injected timestamp
     const injectedCache = new Map();
@@ -29,6 +28,9 @@ export function createInjectProvider(opts) {
         }
     }
     function getInjectionDiagnostics(nowIso, scopeAllowlist, typeAllowlist) {
+        const { db } = runtime;
+        if (!db)
+            return null;
         // Get ALL injects to analyze filtering
         const allInjects = db.prepare("SELECT * FROM injects").all();
         let total = allInjects.length;
@@ -72,6 +74,9 @@ export function createInjectProvider(opts) {
         };
     }
     async function injectEligibleInjects(sessionId, context) {
+        const { db } = runtime;
+        if (!db)
+            return;
         const now = nowISO();
         const nowMs = Date.now();
         // Get allowlists from config or defaults
@@ -90,7 +95,7 @@ export function createInjectProvider(opts) {
         let skippedDeduped = 0;
         if (eligibleInjects.length === 0) {
             // Log when no injects are eligible
-            if (EMIT_TELEMETRY) {
+            if (EMIT_TELEMETRY && diagnostics) {
                 // eslint-disable-next-line no-console
                 console.log(`[Astrocode:inject] ${now} context=${context ?? 'unknown'} selected=0 injected=0 skipped={expired:${diagnostics.skipped.expired} scope:${diagnostics.skipped.scope} type:${diagnostics.skipped.type} deduped:0}`);
             }
@@ -121,7 +126,7 @@ export function createInjectProvider(opts) {
             }
         }
         // Log diagnostic summary
-        if (EMIT_TELEMETRY || injected > 0) {
+        if ((EMIT_TELEMETRY || injected > 0) && diagnostics) {
             // eslint-disable-next-line no-console
             console.log(`[Astrocode:inject] ${now} context=${context ?? 'unknown'} selected=${diagnostics.selected_eligible} injected=${injected} skipped={expired:${diagnostics.skipped.expired} scope:${diagnostics.skipped.scope} type:${diagnostics.skipped.type} deduped:${skippedDeduped}}`);
         }
@@ -138,7 +143,8 @@ export function createInjectProvider(opts) {
     ]);
     // Auto-approve queued stories if enabled
     async function maybeAutoApprove(sessionId) {
-        if (!config.inject?.auto_approve_queued_stories)
+        const { db } = runtime;
+        if (!config.inject?.auto_approve_queued_stories || !db)
             return;
         try {
             // Get all queued stories
@@ -192,6 +198,7 @@ export function createInjectProvider(opts) {
         },
     };
     async function maybeInjectWorkflowPulse(sessionId) {
+        const { db } = runtime;
         if (!db)
             return;
         try {

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

@@ -69,3 +69,12 @@ export type InjectRow = {
     created_at: string;
     updated_at: string;
 };
+import { SqliteDb } from "./db";
+export type RuntimeState = {
+    db: SqliteDb | null;
+    limitedMode: boolean;
+    limitedModeReason: null | {
+        code: "db_init_failed" | "schema_too_old" | "schema_downgrade" | "schema_migration_failed";
+        details: any;
+    };
+};

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

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

package/dist/src/tools/artifacts.js

@@ -3,7 +3,7 @@ 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;
+    const { ctx, runtime } = opts;
     return tool({
         description: "Write an artifact file under .astro and record it in the DB.",
         args: {
@@ -15,6 +15,9 @@ export function createAstroArtifactPutTool(opts) {
             meta_json: tool.schema.string().default("{}"),
         },
         execute: async ({ run_id, stage_key, type, rel_path, content, meta_json }) => {
+            const { db } = runtime;
+            if (!db)
+                return "⚠️ Astrocode not initialized. Run **astro_init** first.";
             const repoRoot = ctx.directory;
             const meta = JSON.parse(meta_json || "{}");
             const res = putArtifact({
@@ -32,7 +35,7 @@ export function createAstroArtifactPutTool(opts) {
     });
 }
 export function createAstroArtifactListTool(opts) {
-    const { db } = opts;
+    const { runtime } = opts;
     return tool({
         description: "List artifacts (optionally filtered by run_id, stage_key, type).",
         args: {
@@ -41,13 +44,16 @@ export function createAstroArtifactListTool(opts) {
             type: tool.schema.string().optional(),
         },
         execute: async ({ run_id, stage_key, type }) => {
+            const { db } = runtime;
+            if (!db)
+                return "⚠️ Astrocode not initialized. Run **astro_init** first.";
             const rows = listArtifacts(db, { run_id, stage_key, type });
             return JSON.stringify(rows, null, 2);
         },
     });
 }
 export function createAstroArtifactGetTool(opts) {
-    const { ctx, config, db } = opts;
+    const { ctx, runtime } = opts;
     return tool({
         description: "Get artifact metadata (and optionally file contents).",
         args: {
@@ -56,6 +62,9 @@ export function createAstroArtifactGetTool(opts) {
             max_body_chars: tool.schema.number().int().positive().default(50_000),
         },
         execute: async ({ artifact_id, include_body, max_body_chars }) => {
+            const { db } = runtime;
+            if (!db)
+                return "⚠️ Astrocode not initialized. Run **astro_init** first.";
             const row = getArtifact(db, artifact_id);
             if (!row)
                 throw new Error(`Artifact not found: ${artifact_id}`);

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

@@ -1,8 +1,8 @@
 import { type ToolDefinition } from "@opencode-ai/plugin/tool";
 import type { AstrocodeConfig } from "../config/schema";
-import type { SqliteDb } from "../state/db";
+import type { RuntimeState } from "../state/types";
 export declare function createAstroHealthTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db: SqliteDb;
+    runtime: RuntimeState;
 }): ToolDefinition;

package/dist/src/tools/health.js

@@ -5,7 +5,7 @@ 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;
+    const { ctx, config, runtime } = opts;
     return tool({
         description: "Check Astrocode health: DB status, locks, schema, active runs, recent events.",
         args: {},
@@ -23,12 +23,21 @@ export function createAstroHealthTool(opts) {
             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`);
+            lines.push(`## Database File`);
+            lines.push(`- Exists: ${dbExists ? "✅" : "❌"}`);
+            lines.push(`- WAL Mode Active: ${walExists ? "YES" : "NO"}`);
+            if (dbExists) {
+                const stats = fs.statSync(fullDbPath);
+                lines.push(`- Size: ${Math.round(stats.size / 1024)} KB`);
+                lines.push(`- Last Modified: ${stats.mtime.toISOString()}`);
+            }
+            const { db } = runtime;
+            if (!db) {
+                lines.push(``, `## Status`);
+                lines.push(`❌ DB not connected (Limited Mode)`);
+                if (runtime.limitedModeReason) {
+                    lines.push(`- Reason: ${runtime.limitedModeReason.code}`);
+                }
                 return lines.join("\n");
             }
             // Schema version
@@ -38,8 +47,6 @@ export function createAstroHealthTool(opts) {
             }
             catch (e) {
                 lines.push(`- Schema Version: ERROR (${String(e)})`);
-                lines.push(`- STATUS: DB CORRUPTED`);
-                return lines.join("\n");
             }
             // Active run
             try {
@@ -51,7 +58,7 @@ export function createAstroHealthTool(opts) {
                     lines.push(`  - Started: ${activeRun.started_at}`);
                 }
                 else {
-                    lines.push(`- Active Run: NONE`);
+                    lines.push(`- Active Run: *(none)*`);
                 }
             }
             catch (e) {
@@ -80,7 +87,7 @@ export function createAstroHealthTool(opts) {
             lines.push(`✅ DB accessible`);
             lines.push(`✅ Schema valid`);
             if (walExists || shmExists) {
-                lines.push(`⚠️ WAL/SHM files present - indicates unclean shutdown or active transaction`);
+                lines.push(`ℹ️ SQLite temporary files present (normal during active use)`);
             }
             return lines.join("\n");
         },

package/dist/src/tools/index.js

@@ -13,47 +13,40 @@ 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_status = createAstroStatusTool({ ctx, config, runtime });
     tools.astro_spec_get = createAstroSpecGetTool({ ctx, config });
-    tools.astro_health = createAstroHealthTool({ ctx, config, db });
-    tools.astro_reset = createAstroResetTool({ ctx, config, db });
+    tools.astro_health = createAstroHealthTool({ ctx, config, runtime });
+    tools.astro_reset = createAstroResetTool({ ctx, config, runtime });
     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
+    // We register these even if runtime.db is null, so they can become active if astro_init succeeds in-process.
+    // The tools themselves must handle the missing DB case gracefully (returning "not initialized").
+    tools.astro_story_queue = createAstroStoryQueueTool({ ctx, config, runtime });
+    tools.astro_story_approve = createAstroStoryApproveTool({ ctx, config, runtime });
+    tools.astro_story_board = createAstroStoryBoardTool({ ctx, config, runtime });
+    tools.astro_story_set_state = createAstroStorySetStateTool({ ctx, config, runtime });
+    tools.astro_spec_set = createAstroSpecSetTool({ ctx, config, runtime });
+    tools.astro_run_get = createAstroRunGetTool({ ctx, config, runtime });
+    tools.astro_run_abort = createAstroRunAbortTool({ ctx, config, runtime });
+    tools.astro_workflow_proceed = createAstroWorkflowProceedTool({ ctx, config, runtime, agents });
+    tools.astro_stage_start = createAstroStageStartTool({ ctx, config, runtime });
+    tools.astro_stage_complete = createAstroStageCompleteTool({ ctx, config, runtime });
+    tools.astro_stage_fail = createAstroStageFailTool({ ctx, config, runtime });
+    tools.astro_stage_reset = createAstroStageResetTool({ ctx, config, runtime });
+    tools.astro_artifact_put = createAstroArtifactPutTool({ ctx, config, runtime });
+    tools.astro_artifact_list = createAstroArtifactListTool({ ctx, config, runtime });
+    tools.astro_artifact_get = createAstroArtifactGetTool({ ctx, config, runtime });
+    tools.astro_inject_put = createAstroInjectPutTool({ ctx, config, runtime });
+    tools.astro_inject_list = createAstroInjectListTool({ ctx, config, runtime });
+    tools.astro_inject_search = createAstroInjectSearchTool({ ctx, config, runtime });
+    tools.astro_inject_get = createAstroInjectGetTool({ ctx, config, runtime });
+    tools.astro_inject_eligible = createAstroInjectEligibleTool({ ctx, config, runtime });
+    tools.astro_inject_debug_due = createAstroInjectDebugDueTool({ ctx, config, runtime });
+    tools.astro_repair = createAstroRepairTool({ ctx, config, runtime });
     const aliases = [
         ["_astro_init", "astro_init"],
         ["_astro_status", "astro_status"],

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

@@ -1,25 +1,25 @@
 import { type ToolDefinition } from "@opencode-ai/plugin/tool";
 import type { AstrocodeConfig } from "../config/schema";
-import type { SqliteDb } from "../state/db";
+import type { RuntimeState } from "../state/types";
 export declare function createAstroInjectPutTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db: SqliteDb;
+    runtime: RuntimeState;
 }): ToolDefinition;
 export declare function createAstroInjectListTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db: SqliteDb;
+    runtime: RuntimeState;
 }): ToolDefinition;
 export declare function createAstroInjectGetTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db: SqliteDb;
+    runtime: RuntimeState;
 }): ToolDefinition;
 export declare function createAstroInjectSearchTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db: SqliteDb;
+    runtime: RuntimeState;
 }): ToolDefinition;
 export type InjectRow = {
     inject_id: string;
@@ -35,7 +35,7 @@ export type InjectRow = {
     created_at: string;
     updated_at: string;
 };
-export declare function selectEligibleInjects(db: SqliteDb, opts: {
+export declare function selectEligibleInjects(db: any, opts: {
     nowIso: string;
     scopeAllowlist: string[];
     typeAllowlist: string[];
@@ -44,10 +44,10 @@ export declare function selectEligibleInjects(db: SqliteDb, opts: {
 export declare function createAstroInjectEligibleTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db: SqliteDb;
+    runtime: RuntimeState;
 }): ToolDefinition;
 export declare function createAstroInjectDebugDueTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db: SqliteDb;
+    runtime: RuntimeState;
 }): ToolDefinition;

package/dist/src/tools/injects.js

@@ -41,7 +41,7 @@ function newInjectId() {
     return `inj_${Date.now()}_${Math.random().toString(16).slice(2)}`;
 }
 export function createAstroInjectPutTool(opts) {
-    const { db } = opts;
+    const { runtime } = opts;
     return tool({
         description: "Create/update an inject (note/policy) stored in the DB. Useful for persistent rules.",
         args: {
@@ -56,6 +56,9 @@ export function createAstroInjectPutTool(opts) {
             expires_at: tool.schema.string().nullable().optional(),
         },
         execute: async ({ inject_id, type, title, body_md, tags_json, scope, source, priority, expires_at }) => {
+            const { db } = runtime;
+            if (!db)
+                return "⚠️ Astrocode not initialized. Run **astro_init** first.";
             const id = inject_id ?? newInjectId();
             const now = nowISO();
             const sha = sha256Hex(body_md);
@@ -109,7 +112,7 @@ export function createAstroInjectPutTool(opts) {
     });
 }
 export function createAstroInjectListTool(opts) {
-    const { db } = opts;
+    const { runtime } = opts;
     return tool({
         description: "List injects (optionally filtered by scope/type).",
         args: {
@@ -118,6 +121,9 @@ export function createAstroInjectListTool(opts) {
             limit: tool.schema.number().int().positive().default(50),
         },
         execute: async ({ scope, type, limit }) => {
+            const { db } = runtime;
+            if (!db)
+                return "⚠️ Astrocode not initialized. Run **astro_init** first.";
             const where = [];
             const params = [];
             if (scope) {
@@ -143,13 +149,16 @@ export function createAstroInjectListTool(opts) {
     });
 }
 export function createAstroInjectGetTool(opts) {
-    const { db } = opts;
+    const { runtime } = opts;
     return tool({
         description: "Get an inject by id (full body).",
         args: {
             inject_id: tool.schema.string().min(1),
         },
         execute: async ({ inject_id }) => {
+            const { db } = runtime;
+            if (!db)
+                return "⚠️ Astrocode not initialized. Run **astro_init** first.";
             const row = db.prepare("SELECT * FROM injects WHERE inject_id=?").get(inject_id);
             if (!row)
                 throw new Error(`Inject not found: ${inject_id}`);
@@ -158,7 +167,7 @@ export function createAstroInjectGetTool(opts) {
     });
 }
 export function createAstroInjectSearchTool(opts) {
-    const { db } = opts;
+    const { runtime } = opts;
     return tool({
         description: "Search injects by query substring over title/body/tags. Returns matches ordered by priority/recency.",
         args: {
@@ -167,6 +176,9 @@ export function createAstroInjectSearchTool(opts) {
             limit: tool.schema.number().int().positive().default(20),
         },
         execute: async ({ q, scope, limit }) => {
+            const { db } = runtime;
+            if (!db)
+                return "⚠️ Astrocode not initialized. Run **astro_init** first.";
             const like = `%${q}%`;
             const where = ["(title LIKE ? OR body_md LIKE ? OR tags_json LIKE ?)"];
             const params = [like, like, like];
@@ -210,7 +222,7 @@ export function selectEligibleInjects(db, opts) {
     return db.prepare(sql).all(...params);
 }
 export function createAstroInjectEligibleTool(opts) {
-    const { db } = opts;
+    const { runtime } = opts;
     return tool({
         description: "Debug: show which injects are eligible right now for injection.",
         args: {
@@ -219,6 +231,9 @@ export function createAstroInjectEligibleTool(opts) {
             limit: tool.schema.number().int().positive().default(50),
         },
         execute: async ({ scopes_json, types_json, limit }) => {
+            const { db } = runtime;
+            if (!db)
+                return "⚠️ Astrocode not initialized. Run **astro_init** first.";
             const now = nowISO();
             const scopes = parseJsonStringArray("scopes_json", scopes_json);
             const types = parseJsonStringArray("types_json", types_json);
@@ -236,7 +251,7 @@ export function createAstroInjectEligibleTool(opts) {
     });
 }
 export function createAstroInjectDebugDueTool(opts) {
-    const { db } = opts;
+    const { runtime } = opts;
     return tool({
         description: "Debug: show comprehensive injection diagnostics - why injects were selected/skipped.",
         args: {
@@ -244,6 +259,9 @@ export function createAstroInjectDebugDueTool(opts) {
             types_json: tool.schema.string().default('["note","policy"]'),
         },
         execute: async ({ scopes_json, types_json }) => {
+            const { db } = runtime;
+            if (!db)
+                return "⚠️ Astrocode not initialized. Run **astro_init** first.";
             const now = nowISO();
             const nowMs = Date.parse(now);
             const scopes = parseJsonStringArray("scopes_json", scopes_json);

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

@@ -1,7 +1,8 @@
 import { type ToolDefinition } from "@opencode-ai/plugin/tool";
-type CreateAstroMetricsToolOptions = {
+import type { AstrocodeConfig } from "../config/schema";
+import type { RuntimeState } from "../state/types";
+export declare function createAstroMetricsTool(opts: {
     ctx: any;
-    config: any;
-};
-export declare function createAstroMetricsTool(opts: CreateAstroMetricsToolOptions): ToolDefinition;
-export {};
+    config: AstrocodeConfig;
+    runtime?: RuntimeState;
+}): ToolDefinition;

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

@@ -1,8 +1,8 @@
 import { type ToolDefinition } from "@opencode-ai/plugin/tool";
 import type { AstrocodeConfig } from "../config/schema";
-import type { SqliteDb } from "../state/db";
+import type { RuntimeState } from "../state/types";
 export declare function createAstroRepairTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db: SqliteDb;
+    runtime: RuntimeState;
 }): ToolDefinition;

package/dist/src/tools/repair.js

@@ -4,13 +4,17 @@ import { repairState, formatRepairReport } from "../workflow/repair";
 import { putArtifact } from "../workflow/artifacts";
 import { nowISO } from "../shared/time";
 export function createAstroRepairTool(opts) {
-    const { ctx, config, db } = opts;
+    const { ctx, config, runtime } = opts;
     return tool({
         description: "Repair Astrocode invariants and recover from inconsistent DB state. Writes a repair report artifact.",
         args: {
             write_report_artifact: tool.schema.boolean().default(true),
         },
         execute: async ({ write_report_artifact }) => {
+            const { db } = runtime;
+            if (!db) {
+                return "⚠️ Cannot run repair: Astrocode is not initialized. Run **astro_init** first.";
+            }
             const repoRoot = ctx.directory;
             // Repair database state
             const report = withTx(db, () => repairState(db, config));

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

@@ -1,8 +1,8 @@
 import { type ToolDefinition } from "@opencode-ai/plugin/tool";
 import type { AstrocodeConfig } from "../config/schema";
-import type { SqliteDb } from "../state/db";
+import type { RuntimeState } from "../state/types";
 export declare function createAstroResetTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db: SqliteDb;
+    runtime: RuntimeState;
 }): ToolDefinition;

package/dist/src/tools/reset.js

@@ -3,7 +3,7 @@ import { tool } from "@opencode-ai/plugin/tool";
 import fs from "node:fs";
 import path from "node:path";
 export function createAstroResetTool(opts) {
-    const { ctx, config, db } = opts;
+    const { ctx, config, runtime } = opts;
     return tool({
         description: "Reset Astrocode database: safely delete all DB files and WAL/SHM after killing concurrent processes.",
         args: {
@@ -23,6 +23,14 @@ export function createAstroResetTool(opts) {
                     "To confirm: astro_reset(confirm=\"RESET\")",
                 ].join("\n");
             }
+            // Close DB connection if open
+            if (runtime.db) {
+                try {
+                    runtime.db.close();
+                }
+                catch { /* ignore */ }
+                runtime.db = null;
+            }
             const repoRoot = ctx.directory || process.cwd();
             const dbPath = config.db?.path || ".astro/astro.db";
             const fullDbPath = path.resolve(repoRoot, dbPath);