astrocode-workflow 0.4.4 → 0.4.6

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);

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

@@ -1,13 +1,13 @@
 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 createAstroRunGetTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db: SqliteDb;
+    runtime: RuntimeState;
 }): ToolDefinition;
 export declare function createAstroRunAbortTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db: SqliteDb;
+    runtime: RuntimeState;
 }): ToolDefinition;

package/dist/src/tools/run.js

@@ -1,7 +1,7 @@
 import { tool } from "@opencode-ai/plugin/tool";
 import { abortRun, getActiveRun, getStageRuns, getStory } from "../workflow/state-machine";
 export function createAstroRunGetTool(opts) {
-    const { db } = opts;
+    const { runtime } = opts;
     return tool({
         description: "Get run details (and stage run statuses). Defaults to active run if run_id omitted.",
         args: {
@@ -9,6 +9,9 @@ export function createAstroRunGetTool(opts) {
             include_stage_summaries: tool.schema.boolean().default(false),
         },
         execute: async ({ run_id, include_stage_summaries }) => {
+            const { db } = runtime;
+            if (!db)
+                return "⚠️ Astrocode not initialized. Run **astro_init** first.";
             const active = getActiveRun(db);
             const rid = run_id ?? active?.run_id;
             if (!rid)
@@ -35,7 +38,7 @@ export function createAstroRunGetTool(opts) {
     });
 }
 export function createAstroRunAbortTool(opts) {
-    const { db } = opts;
+    const { runtime } = opts;
     return tool({
         description: "Abort a run and unlock its story (returns story to approved). Defaults to active run if run_id omitted.",
         args: {
@@ -43,6 +46,9 @@ export function createAstroRunAbortTool(opts) {
             reason: tool.schema.string().default("aborted by user"),
         },
         execute: async ({ run_id, reason }) => {
+            const { db } = runtime;
+            if (!db)
+                return "⚠️ Astrocode not initialized. Run **astro_init** first.";
             const active = getActiveRun(db);
             const rid = run_id ?? active?.run_id;
             if (!rid)

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

@@ -1,6 +1,6 @@
 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 createAstroSpecGetTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
@@ -8,5 +8,5 @@ export declare function createAstroSpecGetTool(opts: {
 export declare function createAstroSpecSetTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db: SqliteDb;
+    runtime: RuntimeState;
 }): ToolDefinition;

package/dist/src/tools/spec.js

@@ -21,15 +21,16 @@ export function createAstroSpecGetTool(opts) {
     });
 }
 export function createAstroSpecSetTool(opts) {
-    const { ctx, config, db } = opts;
+    const { ctx, config, runtime } = opts;
     return tool({
         description: "Set/replace the project spec at .astro/spec.md and record its hash in the DB.",
         args: {
             spec_md: tool.schema.string().min(1),
         },
         execute: async ({ spec_md }) => {
+            const { db } = runtime;
             if (!db) {
-                return "❌ Database not available. Cannot track spec hash. Astrocode is running in limited mode.";
+                return "❌ Database not available. Cannot track spec hash. Astrocode is running in limited mode. Run **astro_init** first.";
             }
             const repoRoot = ctx.directory;
             const paths = getAstroPaths(repoRoot, config.db.path);

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

@@ -1,23 +1,23 @@
 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 createAstroStageStartTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db: SqliteDb;
+    runtime: RuntimeState;
 }): ToolDefinition;
 export declare function createAstroStageCompleteTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db: SqliteDb;
+    runtime: RuntimeState;
 }): ToolDefinition;
 export declare function createAstroStageFailTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db: SqliteDb;
+    runtime: RuntimeState;
 }): ToolDefinition;
 export declare function createAstroStageResetTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db: SqliteDb;
+    runtime: RuntimeState;
 }): ToolDefinition;

package/dist/src/tools/stage.js

@@ -54,7 +54,7 @@ function splitTasksIntoStories(db, tasks, run, now, newStoryKeys, relationReason
     }
 }
 export function createAstroStageStartTool(opts) {
-    const { config, db } = opts;
+    const { runtime } = opts;
     return tool({
         description: "Start a stage for a run (sets stage_run.status=running). Usually called by astro_workflow_proceed.",
         args: {
@@ -64,6 +64,9 @@ export function createAstroStageStartTool(opts) {
             subagent_session_id: tool.schema.string().optional(),
         },
         execute: async ({ run_id, stage_key, subagent_type, subagent_session_id }) => {
+            const { db } = runtime;
+            if (!db)
+                return "⚠️ Astrocode not initialized. Run **astro_init** first.";
             const active = getActiveRun(db);
             const rid = run_id ?? active?.run_id;
             if (!rid)
@@ -80,7 +83,7 @@ export function createAstroStageStartTool(opts) {
     });
 }
 export function createAstroStageCompleteTool(opts) {
-    const { ctx, config, db } = opts;
+    const { ctx, config, runtime } = opts;
     return tool({
         description: "Complete a stage from stage-agent output text. Writes baton artifacts, updates stage_runs, advances pipeline, and can auto-queue split stories.",
         args: {
@@ -92,6 +95,9 @@ export function createAstroStageCompleteTool(opts) {
             relation_reason: tool.schema.string().default("split from stage output"),
         },
         execute: async ({ run_id, stage_key, output_text, allow_new_stories, relation_reason }) => {
+            const { db } = runtime;
+            if (!db)
+                return "⚠️ Astrocode not initialized. Run **astro_init** first.";
             const repoRoot = ctx.directory;
             const paths = getAstroPaths(repoRoot, config.db.path);
             ensureAstroDirs(paths);
@@ -305,7 +311,7 @@ Ensure JSON has required fields (stage_key, status) and valid syntax.`;
     });
 }
 export function createAstroStageFailTool(opts) {
-    const { db } = opts;
+    const { runtime } = opts;
     return tool({
         description: "Manually fail a stage and mark run failed.",
         args: {
@@ -314,6 +320,9 @@ export function createAstroStageFailTool(opts) {
             error_text: tool.schema.string().min(1),
         },
         execute: async ({ run_id, stage_key, error_text }) => {
+            const { db } = runtime;
+            if (!db)
+                return "⚠️ Astrocode not initialized. Run **astro_init** first.";
             const active = getActiveRun(db);
             const rid = run_id ?? active?.run_id;
             if (!rid)
@@ -339,7 +348,7 @@ export function createAstroStageFailTool(opts) {
     });
 }
 export function createAstroStageResetTool(opts) {
-    const { db } = opts;
+    const { runtime } = opts;
     return tool({
         description: "Admin: reset a stage (and later stages) back to pending for a run. Re-opens run as running. Use carefully.",
         args: {
@@ -348,6 +357,9 @@ export function createAstroStageResetTool(opts) {
             note: tool.schema.string().default("reset by user"),
         },
         execute: async ({ run_id, stage_key, note }) => {
+            const { db } = runtime;
+            if (!db)
+                return "⚠️ Astrocode not initialized. Run **astro_init** first.";
             const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(run_id);
             if (!run)
                 throw new Error(`Run not found: ${run_id}`);

package/dist/src/tools/status.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 createAstroStatusTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db?: SqliteDb | null;
+    runtime: RuntimeState;
 }): ToolDefinition;

package/dist/src/tools/status.js

@@ -1,5 +1,8 @@
 import { tool } from "@opencode-ai/plugin/tool";
 import { decideNextAction, getActiveRun, getStageRuns, getStory } from "../workflow/state-machine";
+import { openSqlite, configurePragmas, ensureSchema } from "../state/db";
+import { getAstroPaths } from "../shared/paths";
+import fs from "node:fs";
 function statusIcon(status) {
     switch (status) {
         case "running":
@@ -31,7 +34,7 @@ function stageIcon(status) {
     }
 }
 export function createAstroStatusTool(opts) {
-    const { ctx, config, db } = opts;
+    const { ctx, config, runtime } = opts;
     return tool({
         description: "Show a compact Astrocode status dashboard: active run/stage, pipeline, story board counts, and next action.",
         args: {
@@ -39,17 +42,37 @@ export function createAstroStatusTool(opts) {
             include_recent_events: tool.schema.boolean().default(false),
         },
         execute: async ({ include_board, include_recent_events }) => {
+            // Lazy initialization: if DB is missing but file exists, try to connect
+            if (!runtime.db) {
+                const repoRoot = ctx.directory || process.cwd();
+                const paths = getAstroPaths(repoRoot, config.db.path);
+                if (fs.existsSync(paths.dbPath)) {
+                    try {
+                        const db = openSqlite(paths.dbPath, { busyTimeoutMs: config.db.busy_timeout_ms });
+                        configurePragmas(db, config.db.pragmas);
+                        ensureSchema(db, { allowAutoMigrate: config.db.allow_auto_migrate, silent: true });
+                        runtime.db = db;
+                        runtime.limitedMode = false;
+                        runtime.limitedModeReason = null;
+                    }
+                    catch {
+                        // Ignore lazy init failures, will fall through to "not initialized" message
+                    }
+                }
+            }
+            const { db } = runtime;
             if (!db) {
                 return [
                     `⚠️ Astrocode not initialized.`,
                     ``,
                     `- Reason: Database not available`,
                     ``,
-                    `Next: run **astro_init**, then restart the agent/runtime, then run /astro-status.`,
+                    `Next: run **astro_init**, then run /astro-status again.`,
                 ].join("\n");
             }
             try {
                 const active = getActiveRun(db);
+                // ... rest of existing logic ...
                 const lines = [];
                 lines.push(`# Astrocode Status`);
                 if (!active) {

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

@@ -1,23 +1,23 @@
 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 createAstroStoryQueueTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db: SqliteDb;
+    runtime: RuntimeState;
 }): ToolDefinition;
 export declare function createAstroStoryApproveTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db: SqliteDb;
+    runtime: RuntimeState;
 }): ToolDefinition;
 export declare function createAstroStoryBoardTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db: SqliteDb;
+    runtime: RuntimeState;
 }): ToolDefinition;
 export declare function createAstroStorySetStateTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db: SqliteDb;
+    runtime: RuntimeState;
 }): ToolDefinition;

package/dist/src/tools/story.js

@@ -3,7 +3,7 @@ import { withTx } from "../state/db";
 import { nowISO } from "../shared/time";
 import { insertStory } from "../workflow/story-helpers";
 export function createAstroStoryQueueTool(opts) {
-    const { db } = opts;
+    const { runtime } = opts;
     return tool({
         description: "Create a queued story (ticket) in Astrocode. Returns story_key.",
         args: {
@@ -13,6 +13,9 @@ export function createAstroStoryQueueTool(opts) {
             priority: tool.schema.number().int().default(0),
         },
         execute: async ({ title, body_md, epic_key, priority }) => {
+            const { db } = runtime;
+            if (!db)
+                return "⚠️ Astrocode not initialized. Run **astro_init** first.";
             const story_key = withTx(db, () => {
                 const key = insertStory(db, { title, body_md, epic_key: epic_key ?? null, priority: priority ?? 0, state: 'queued' });
                 return key;
@@ -22,13 +25,16 @@ export function createAstroStoryQueueTool(opts) {
     });
 }
 export function createAstroStoryApproveTool(opts) {
-    const { db } = opts;
+    const { runtime } = opts;
     return tool({
         description: "Approve a story so it becomes eligible to run.",
         args: {
             story_key: tool.schema.string().min(1),
         },
         execute: async ({ story_key }) => {
+            const { db } = runtime;
+            if (!db)
+                return "⚠️ Astrocode not initialized. Run **astro_init** first.";
             const now = nowISO();
             const row = db.prepare("SELECT story_key, state, title FROM stories WHERE story_key=?").get(story_key);
             if (!row)
@@ -41,13 +47,16 @@ export function createAstroStoryApproveTool(opts) {
     });
 }
 export function createAstroStoryBoardTool(opts) {
-    const { db } = opts;
+    const { runtime } = opts;
     return tool({
         description: "Show stories grouped by state (a compact board).",
         args: {
             limit_per_state: tool.schema.number().int().positive().default(20),
         },
         execute: async ({ limit_per_state }) => {
+            const { db } = runtime;
+            if (!db)
+                return "⚠️ Astrocode not initialized. Run **astro_init** first.";
             const states = ["queued", "approved", "in_progress", "blocked", "done", "archived"];
             const lines = [];
             lines.push("# Story board");
@@ -64,7 +73,7 @@ export function createAstroStoryBoardTool(opts) {
     });
 }
 export function createAstroStorySetStateTool(opts) {
-    const { db } = opts;
+    const { runtime } = opts;
     return tool({
         description: "Admin: set story state manually (queued|approved|in_progress|done|blocked|archived). Use carefully.",
         args: {
@@ -73,6 +82,9 @@ export function createAstroStorySetStateTool(opts) {
             note: tool.schema.string().default(""),
         },
         execute: async ({ story_key, state, note }) => {
+            const { db } = runtime;
+            if (!db)
+                return "⚠️ Astrocode not initialized. Run **astro_init** first.";
             const now = nowISO();
             const row = db.prepare("SELECT story_key, title, state FROM stories WHERE story_key=?").get(story_key);
             if (!row)

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

@@ -1,6 +1,6 @@
 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";
 import type { StageKey } from "../state/types";
 import type { AgentConfig } from "@opencode-ai/sdk";
 export declare const STAGE_TO_AGENT_MAP: Record<string, string>;
@@ -8,6 +8,6 @@ export declare function resolveAgentName(stageKey: StageKey, config: AstrocodeCo
 export declare function createAstroWorkflowProceedTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db: SqliteDb;
+    runtime: RuntimeState;
     agents?: Record<string, AgentConfig>;
 }): ToolDefinition;

package/dist/src/tools/workflow.js

@@ -143,7 +143,7 @@ function buildUiMessage(e) {
     }
 }
 export function createAstroWorkflowProceedTool(opts) {
-    const { ctx, config, db, agents } = opts;
+    const { ctx, config, runtime, agents } = opts;
     const toasts = createToastManager({ ctx, throttleMs: config.ui.toasts.throttle_ms });
     return tool({
         description: "Deterministic harness: advances the DB-driven pipeline by one step (or loops bounded). Stops when LLM work is required (delegation/await).",
@@ -152,6 +152,10 @@ export function createAstroWorkflowProceedTool(opts) {
             max_steps: tool.schema.number().int().positive().default(config.workflow.default_max_steps),
         },
         execute: async ({ mode, max_steps }) => {
+            const { db } = runtime;
+            if (!db) {
+                return "⚠️ Cannot proceed: Astrocode is not initialized. Run **astro_init** first.";
+            }
             const sessionId = ctx.sessionID;
             const steps = Math.min(max_steps, config.workflow.loop_max_steps_hard_cap);
             const actions = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astrocode-workflow",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/hooks/continuation-enforcer.ts

@@ -1,5 +1,5 @@
 import type { AstrocodeConfig } from "../config/schema";
-import type { SqliteDb } from "../state/db";
+import type { RuntimeState } from "../state/types";
 import { buildContextSnapshot } from "../workflow/context";
 import { decideNextAction, getActiveRun } from "../workflow/state-machine";
 import { buildContinueDirective, type BuiltDirective } from "../workflow/directives";
@@ -35,19 +35,12 @@ function msFromIso(iso: string): number {
   return Number.isFinite(t) ? t : 0;
 }
 
-type RuntimeState = {
-  db: SqliteDb | null;
-  limitedMode: boolean;
-  limitedModeReason: null | { code: "db_init_failed"|"schema_too_old"|"schema_downgrade"|"schema_migration_failed"; details: any };
-};
-
 export function createContinuationEnforcer(opts: {
   ctx: any;
   config: AstrocodeConfig;
   runtime: RuntimeState;
 }) {
   const { ctx, config, runtime } = opts;
-  const { db } = runtime;
 
   const toasts = createToastManager({ ctx, throttleMs: config.ui.toasts.throttle_ms });
 
@@ -106,6 +99,9 @@ export function createContinuationEnforcer(opts: {
   }
 
   function shouldDedupe(sessionId: string, directive: BuiltDirective): boolean {
+    const { db } = runtime;
+    if (!db) return false;
+
     const s = getState(sessionId);
     const now = Date.now();
 
@@ -128,6 +124,9 @@ export function createContinuationEnforcer(opts: {
   }
 
   async function recordContinuation(sessionId: string, runId: string | null, directive: BuiltDirective, reason: string) {
+    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());
@@ -163,7 +162,8 @@ export function createContinuationEnforcer(opts: {
   }
 
   async function maybeInjectContinue(sessionId: string, reason: string) {
-    if (!config.continuation.enabled) return;
+    const { db } = runtime;
+    if (!config.continuation.enabled || !db) return;
 
     // Require active run
     const active = getActiveRun(db);
@@ -213,6 +213,7 @@ export function createContinuationEnforcer(opts: {
     async onToolAfter(input: ToolExecuteAfterInput) {
       const sessionId = input.sessionID ?? (ctx as any).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
@@ -222,6 +223,7 @@ export function createContinuationEnforcer(opts: {
     },
 
     async onChatMessage(_input: ChatMessageInput) {
+      if (!config.continuation.enabled) return;
       if (!config.continuation.inject_on_message_done_if_run_active) return;
       scheduleIdleInjection(_input.sessionID);
     },

package/src/hooks/inject-provider.ts

@@ -1,5 +1,5 @@
 import type { AstrocodeConfig } from "../config/schema";
-import type { SqliteDb } from "../state/db";
+import type { RuntimeState } from "../state/types";
 import { selectEligibleInjects } from "../tools/injects";
 import { injectChatPrompt } from "../ui/inject";
 import { nowISO } from "../shared/time";
@@ -15,19 +15,12 @@ type ToolExecuteAfterInput = {
   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 function createInjectProvider(opts: {
   ctx: any;
   config: AstrocodeConfig;
   runtime: RuntimeState;
 }) {
   const { ctx, config, runtime } = opts;
-  const { db } = runtime;
 
   // Cache to avoid re-injecting the same injects repeatedly
   // Map of inject_id -> last injected timestamp
@@ -57,6 +50,9 @@ export function createInjectProvider(opts: {
   }
 
   function getInjectionDiagnostics(nowIso: string, scopeAllowlist: string[], typeAllowlist: string[]): any {
+    const { db } = runtime;
+    if (!db) return null;
+
     // Get ALL injects to analyze filtering
     const allInjects = db.prepare("SELECT * FROM injects").all() as any[];
 
@@ -107,6 +103,9 @@ export function createInjectProvider(opts: {
   }
 
   async function injectEligibleInjects(sessionId: string, context?: string) {
+    const { db } = runtime;
+    if (!db) return;
+
     const now = nowISO();
     const nowMs = Date.now();
 
@@ -130,7 +129,7 @@ export function createInjectProvider(opts: {
 
     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}`);
       }
@@ -145,7 +144,7 @@ export function createInjectProvider(opts: {
       }
 
       // Format as injection message
-      const formattedText = `[Inject: ${inject.title}]\n\n${inject.body_md}`;
+      const formattedText = `### 🔖 ASTROCODE: INJECTED NOTE\n**Title:** ${inject.title}\n\n${inject.body_md}`;
 
       try {
         await injectChatPrompt({
@@ -165,7 +164,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}}`);
     }
@@ -184,7 +183,8 @@ export function createInjectProvider(opts: {
 
   // Auto-approve queued stories if enabled
   async function maybeAutoApprove(sessionId: string) {
-    if (!config.inject?.auto_approve_queued_stories) return;
+    const { db } = runtime;
+    if (!config.inject?.auto_approve_queued_stories || !db) return;
 
     try {
       // Get all queued stories
@@ -219,6 +219,9 @@ export function createInjectProvider(opts: {
 
       // Inject eligible injects before processing the user's message
       await injectEligibleInjects(input.sessionID, 'chat_message');
+
+      // Also inject Workflow Pulse on chat messages if a run is active
+      await maybeInjectWorkflowPulse(input.sessionID);
     },
 
     async onToolAfter(input: ToolExecuteAfterInput) {
@@ -243,6 +246,7 @@ export function createInjectProvider(opts: {
   };
 
   async function maybeInjectWorkflowPulse(sessionId: string) {
+    const { db } = runtime;
     if (!db) return;
     try {
       const active = getActiveRun(db);

package/src/state/types.ts

@@ -75,3 +75,14 @@ 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;
+  };
+};