astrocode-workflow 0.1.58 → 0.2.0

package/dist/tools/index.d.ts

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

package/dist/tools/index.js

@@ -9,17 +9,21 @@ import { createAstroArtifactPutTool, createAstroArtifactListTool, createAstroArt
 import { createAstroInjectPutTool, createAstroInjectListTool, createAstroInjectSearchTool, createAstroInjectGetTool, createAstroInjectEligibleTool, createAstroInjectDebugDueTool } from "./injects";
 import { createAstroRepairTool } from "./repair";
 export function createAstroTools(opts) {
-    const { ctx, config, db, agents } = opts;
-    const hasDatabase = !!db;
+    const { ctx, config, agents, runtime } = opts;
+    const { db } = runtime;
+    const hasDatabase = db !== null; // Source of truth: DB availability
     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 });
+    // Always available tools (work without database - guaranteed DB-independent)
+    tools.astro_status = createAstroStatusTool({ ctx, config });
+    tools.astro_spec_get = createAstroSpecGetTool({ 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) {
-        tools.astro_init = createAstroInitTool({ ctx, config, db });
+        // 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 });
@@ -43,29 +47,6 @@ export function createAstroTools(opts) {
         tools.astro_inject_debug_due = createAstroInjectDebugDueTool({ 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"],
@@ -90,6 +71,8 @@ export function createAstroTools(opts) {
         ["_astro_inject_list", "astro_inject_list"],
         ["_astro_inject_search", "astro_inject_search"],
         ["_astro_inject_get", "astro_inject_get"],
+        ["_astro_inject_eligible", "astro_inject_eligible"],
+        ["_astro_inject_debug_due", "astro_inject_debug_due"],
         ["_astro_repair", "astro_repair"],
     ];
     // Only add aliases for tools that exist

package/dist/tools/init.d.ts

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

package/dist/tools/init.js

@@ -1,12 +1,12 @@
 import fs from "node:fs";
 import path from "node:path";
 import { tool } from "@opencode-ai/plugin/tool";
-import { ensureSchema } from "../state/db";
+import { ensureSchema, openSqlite, configurePragmas } 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;
+    const { ctx, config, runtime } = 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: {
@@ -17,25 +17,80 @@ export function createAstroInitTool(opts) {
             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 hadDbAlready = !!runtime.db;
+            let db = runtime.db;
+            let publishedToRuntime = false;
+            try {
+                if (!db) {
+                    try {
+                        db = openSqlite(paths.dbPath, { busyTimeoutMs: config.db.busy_timeout_ms });
+                        configurePragmas(db, config.db.pragmas);
+                    }
+                    catch (e) {
+                        const msg = e instanceof Error ? e.message : String(e);
+                        throw new Error(`❌ Failed to open database at ${paths.dbPath}: ${msg}. Install a SQLite driver (better-sqlite3/bun:sqlite) and check file permissions.`);
+                    }
+                }
+                // Source-of-truth for schema + repo_state invariants.
+                ensureSchema(db, { allowAutoMigrate: config.db.allow_auto_migrate });
+                // Postcondition: repo_state must exist after ensureSchema.
+                try {
+                    db.prepare("SELECT schema_version FROM repo_state WHERE id = 1").get();
+                }
+                catch (e) {
+                    const msg = e instanceof Error ? e.message : String(e);
+                    throw new Error(`❌ Schema initialization incomplete: repo_state missing/unreadable after ensureSchema (${msg})`);
+                }
+                if (ensure_spec) {
+                    if (!fs.existsSync(paths.specPath)) {
+                        fs.writeFileSync(paths.specPath, spec_placeholder);
+                    }
+                    const content = fs.readFileSync(paths.specPath, "utf8");
+                    const specHash = sha256Hex(content);
                     const now = nowISO();
-                    db.prepare("UPDATE repo_state SET spec_hash_after=?, updated_at=? WHERE id=1").run(specHash, now);
+                    // Update hash; fail with a clear error if schema is mismatched.
+                    try {
+                        db.prepare(`
+              UPDATE repo_state
+              SET spec_hash_after = ?, updated_at = ?
+              WHERE id = 1
+            `).run(specHash, now);
+                    }
+                    catch (e) {
+                        const msg = e instanceof Error ? e.message : String(e);
+                        throw new Error(`❌ Failed to update repo_state spec hash (schema mismatch?): ${msg}`);
+                    }
+                }
+                // Best-effort: if we recovered DB in-process, publish it so the harness can use it immediately.
+                // (If your harness reads runtime at creation-time only, this still helps future tool calls.)
+                if (!hadDbAlready && db) {
+                    runtime.db = db;
+                    runtime.limitedMode = false;
+                    runtime.limitedModeReason = null;
+                    publishedToRuntime = true;
+                }
+                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)}`,
+                    ``,
+                    publishedToRuntime
+                        ? `Next: run /astro-status. (DB recovered in-process.)`
+                        : `Next: restart the agent/runtime if Astrocode is still in Limited Mode, then run /astro-status.`,
+                ].join("\n");
+            }
+            finally {
+                // Only close if this tool opened it AND we did not publish it for ongoing use.
+                if (!hadDbAlready && !publishedToRuntime && db && typeof db.close === "function") {
+                    try {
+                        db.close();
+                    }
+                    catch { }
                 }
             }
-            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.js

@@ -2,28 +2,41 @@ import { tool } from "@opencode-ai/plugin/tool";
 import { withTx } from "../state/db";
 import { nowISO } from "../shared/time";
 import { sha256Hex } from "../shared/hash";
-const VALID_INJECT_TYPES = ['note', 'policy', 'reminder', 'debug'];
+const VALID_INJECT_TYPES = ["note", "policy", "reminder", "debug"];
 function validateInjectType(type) {
     if (!VALID_INJECT_TYPES.includes(type)) {
-        throw new Error(`Invalid inject type "${type}". Must be one of: ${VALID_INJECT_TYPES.join(', ')}`);
+        throw new Error(`Invalid inject type "${type}". Must be one of: ${VALID_INJECT_TYPES.join(", ")}`);
     }
     return type;
 }
 function validateTimestamp(timestamp) {
     if (!timestamp)
         return null;
-    // Check if it's a valid ISO 8601 timestamp with Z suffix
+    // Strict ISO 8601 UTC with Z suffix, sortable as string.
     const isoRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z$/;
     if (!isoRegex.test(timestamp)) {
         throw new Error(`Invalid timestamp format. Expected ISO 8601 UTC with Z suffix (e.g., "2026-01-23T13:05:19.000Z"), got: "${timestamp}"`);
     }
-    // Additional validation: ensure it's parseable and represents a valid date
-    const parsed = new Date(timestamp);
-    if (isNaN(parsed.getTime())) {
+    const parsed = Date.parse(timestamp);
+    if (!Number.isFinite(parsed)) {
         throw new Error(`Invalid timestamp: "${timestamp}" does not represent a valid date`);
     }
     return timestamp;
 }
+function parseJsonStringArray(name, raw) {
+    let v;
+    try {
+        v = JSON.parse(raw);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new Error(`${name} must be valid JSON. Parse error: ${msg}`);
+    }
+    if (!Array.isArray(v) || !v.every((x) => typeof x === "string")) {
+        throw new Error(`${name} must be a JSON array of strings`);
+    }
+    return v;
+}
 function newInjectId() {
     return `inj_${Date.now()}_${Math.random().toString(16).slice(2)}`;
 }
@@ -46,15 +59,34 @@ export function createAstroInjectPutTool(opts) {
             const id = inject_id ?? newInjectId();
             const now = nowISO();
             const sha = sha256Hex(body_md);
-            // Validate inputs
             const validatedType = validateInjectType(type);
             const validatedExpiresAt = validateTimestamp(expires_at);
+            // Ensure tags_json is at least valid JSON (we do not enforce schema here beyond validity).
+            try {
+                JSON.parse(tags_json);
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                throw new Error(`tags_json must be valid JSON. Parse error: ${msg}`);
+            }
             return withTx(db, () => {
                 const existing = db.prepare("SELECT inject_id FROM injects WHERE inject_id=?").get(id);
                 if (existing) {
-                    // Use INSERT ... ON CONFLICT for atomic updates
                     db.prepare(`
-            INSERT INTO injects (inject_id, type, title, body_md, tags_json, scope, source, priority, expires_at, sha256, created_at, updated_at)
+            INSERT INTO injects (
+              inject_id,
+              type,
+              title,
+              body_md,
+              tags_json,
+              scope,
+              source,
+              priority,
+              expires_at,
+              sha256,
+              created_at,
+              updated_at
+            )
             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
             ON CONFLICT(inject_id) DO UPDATE SET
               type=excluded.type,
@@ -67,7 +99,7 @@ export function createAstroInjectPutTool(opts) {
               expires_at=excluded.expires_at,
               sha256=excluded.sha256,
               updated_at=excluded.updated_at
-          `).run(id, type, title, body_md, tags_json, scope, source, priority, validatedExpiresAt, sha, now, now);
+          `).run(id, validatedType, title, body_md, tags_json, scope, source, priority, validatedExpiresAt, sha, now, now);
                     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, validatedType, title, body_md, tags_json, scope, source, priority, validatedExpiresAt, sha, now, now);
@@ -93,10 +125,18 @@ export function createAstroInjectListTool(opts) {
                 params.push(scope);
             }
             if (type) {
+                // Keep list tool permissive (debugging), but still prevents obvious garbage if used.
+                validateInjectType(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 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);
             return JSON.stringify(rows, null, 2);
         },
@@ -134,7 +174,13 @@ export function createAstroInjectSearchTool(opts) {
                 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 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);
             return JSON.stringify(rows, null, 2);
         },
@@ -142,7 +188,13 @@ export function createAstroInjectSearchTool(opts) {
 }
 export function selectEligibleInjects(db, opts) {
     const { nowIso, scopeAllowlist, typeAllowlist, limit = 50 } = opts;
-    // Build placeholders safely
+    if (!Array.isArray(scopeAllowlist) || scopeAllowlist.length === 0) {
+        throw new Error("selectEligibleInjects: scopeAllowlist must be a non-empty array");
+    }
+    if (!Array.isArray(typeAllowlist) || typeAllowlist.length === 0) {
+        throw new Error("selectEligibleInjects: typeAllowlist must be a non-empty array");
+    }
+    // Build placeholders safely (guaranteed non-empty).
     const scopeQs = scopeAllowlist.map(() => "?").join(", ");
     const typeQs = typeAllowlist.map(() => "?").join(", ");
     const sql = `
@@ -168,8 +220,11 @@ export function createAstroInjectEligibleTool(opts) {
         },
         execute: async ({ scopes_json, types_json, limit }) => {
             const now = nowISO();
-            const scopes = JSON.parse(scopes_json);
-            const types = JSON.parse(types_json);
+            const scopes = parseJsonStringArray("scopes_json", scopes_json);
+            const types = parseJsonStringArray("types_json", types_json);
+            // Validate types against the known set to keep selection sane.
+            for (const t of types)
+                validateInjectType(t);
             const rows = selectEligibleInjects(db, {
                 nowIso: now,
                 scopeAllowlist: scopes,
@@ -190,30 +245,38 @@ export function createAstroInjectDebugDueTool(opts) {
         },
         execute: async ({ scopes_json, types_json }) => {
             const now = nowISO();
-            const scopes = JSON.parse(scopes_json);
-            const types = JSON.parse(types_json);
-            // Get ALL injects to analyze filtering
+            const nowMs = Date.parse(now);
+            const scopes = parseJsonStringArray("scopes_json", scopes_json);
+            const types = parseJsonStringArray("types_json", types_json);
+            for (const t of types)
+                validateInjectType(t);
             const allInjects = db.prepare("SELECT * FROM injects").all();
             let total = allInjects.length;
             let selected = 0;
             let skippedExpired = 0;
             let skippedScope = 0;
             let skippedType = 0;
+            let skippedUnparseableExpiresAt = 0;
             const excludedReasons = [];
             const selectedInjects = [];
             for (const inject of allInjects) {
                 const reasons = [];
-                // Check expiration
-                if (inject.expires_at && inject.expires_at <= now) {
-                    reasons.push("expired");
-                    skippedExpired++;
+                // Expiration: parse to ms for correctness across legacy rows.
+                if (inject.expires_at) {
+                    const expMs = Date.parse(String(inject.expires_at));
+                    if (!Number.isFinite(expMs)) {
+                        reasons.push("expires_at_unparseable");
+                        skippedUnparseableExpiresAt++;
+                    }
+                    else if (expMs <= nowMs) {
+                        reasons.push("expired");
+                        skippedExpired++;
+                    }
                 }
-                // Check scope
                 if (!scopes.includes(inject.scope)) {
                     reasons.push("scope");
                     skippedScope++;
                 }
-                // Check type
                 if (!types.includes(inject.type)) {
                     reasons.push("type");
                     skippedType++;
@@ -222,7 +285,7 @@ export function createAstroInjectDebugDueTool(opts) {
                     excludedReasons.push({
                         inject_id: inject.inject_id,
                         title: inject.title,
-                        reasons: reasons,
+                        reasons,
                         scope: inject.scope,
                         type: inject.type,
                         expires_at: inject.expires_at,
@@ -249,9 +312,10 @@ export function createAstroInjectDebugDueTool(opts) {
                     excluded_total: total - selected,
                     skipped_breakdown: {
                         expired: skippedExpired,
+                        expires_at_unparseable: skippedUnparseableExpiresAt,
                         scope: skippedScope,
                         type: skippedType,
-                    }
+                    },
                 },
                 selected_injects: selectedInjects,
                 excluded_injects: excludedReasons,

package/dist/tools/spec.d.ts

@@ -4,7 +4,6 @@ import type { SqliteDb } from "../state/db";
 export declare function createAstroSpecGetTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db: SqliteDb;
 }): ToolDefinition;
 export declare function createAstroSpecSetTool(opts: {
     ctx: any;

package/dist/tools/spec.js

@@ -5,7 +5,7 @@ import { getAstroPaths, ensureAstroDirs } from "../shared/paths";
 import { nowISO } from "../shared/time";
 import { sha256Hex } from "../shared/hash";
 export function createAstroSpecGetTool(opts) {
-    const { ctx, config, db } = opts;
+    const { ctx, config } = opts;
     return tool({
         description: "Get current project spec stored at .astro/spec.md",
         args: {},
@@ -28,6 +28,9 @@ export function createAstroSpecSetTool(opts) {
             spec_md: tool.schema.string().min(1),
         },
         execute: async ({ spec_md }) => {
+            if (!db) {
+                return "❌ Database not available. Cannot track spec hash. Astrocode is running in limited mode.";
+            }
             const repoRoot = ctx.directory;
             const paths = getAstroPaths(repoRoot, config.db.path);
             ensureAstroDirs(paths);

package/dist/tools/status.d.ts

@@ -4,5 +4,5 @@ import type { SqliteDb } from "../state/db";
 export declare function createAstroStatusTool(opts: {
     ctx: any;
     config: AstrocodeConfig;
-    db: SqliteDb;
+    db?: SqliteDb | null;
 }): ToolDefinition;

package/dist/tools/status.js

@@ -39,69 +39,87 @@ export function createAstroStatusTool(opts) {
             include_recent_events: tool.schema.boolean().default(false),
         },
         execute: async ({ include_board, include_recent_events }) => {
-            // Check if database is available
             if (!db) {
-                return "🔄 Astrocode Status\n\n⚠️ Limited Mode: Database not available\nAstrocode is running with reduced functionality";
+                return [
+                    `⚠️ Astrocode not initialized.`,
+                    ``,
+                    `- Reason: Database not available`,
+                    ``,
+                    `Next: run **astro_init**, then restart the agent/runtime, then run /astro-status.`,
+                ].join("\n");
             }
-            const active = getActiveRun(db);
-            const lines = [];
-            lines.push(`# Astrocode Status`);
-            if (!active) {
-                lines.push(`- Active run: *(none)*`);
+            try {
+                const active = getActiveRun(db);
+                const lines = [];
+                lines.push(`# Astrocode Status`);
+                if (!active) {
+                    lines.push(`- Active run: *(none)*`);
+                    const next = decideNextAction(db, config);
+                    if (next.kind === "idle")
+                        lines.push(`- Next: ${next.reason === "no_approved_stories" ? "No approved stories." : "Idle."}`);
+                    if (include_board) {
+                        const counts = db.prepare("SELECT state, COUNT(*) as c FROM stories GROUP BY state ORDER BY state").all();
+                        lines.push(``, `## Story board`);
+                        for (const row of counts)
+                            lines.push(`- ${row.state}: ${row.c}`);
+                    }
+                    return lines.join("\n");
+                }
+                const story = getStory(db, active.story_key);
+                const stageRuns = getStageRuns(db, active.run_id);
+                lines.push(`- Active run: \`${active.run_id}\` ${statusIcon(active.status)} **${active.status}**`);
+                lines.push(`- Story: \`${active.story_key}\` — ${story?.title ?? "(missing)"}  (${story?.state ?? "?"})`);
+                lines.push(`- Current stage: \`${active.current_stage_key ?? "?"}\``);
+                lines.push(``, `## Pipeline`);
+                for (const s of stageRuns)
+                    lines.push(`- ${stageIcon(s.status)} \`${s.stage_key}\` (${s.status})`);
                 const next = decideNextAction(db, config);
-                if (next.kind === "idle")
-                    lines.push(`- Next: ${next.reason === "no_approved_stories" ? "No approved stories." : "Idle."}`);
+                lines.push(``, `## Next`, `- ${next.kind}`);
+                if (next.kind === "await_stage_completion") {
+                    lines.push(`- Awaiting output for stage \`${next.stage_key}\`. When you have it, call **astro_stage_complete** with the stage output text.`);
+                }
+                else if (next.kind === "delegate_stage") {
+                    lines.push(`- Need to run stage \`${next.stage_key}\`. Use **astro_workflow_proceed** (or delegate to the matching stage agent).`);
+                }
+                else if (next.kind === "complete_run") {
+                    lines.push(`- All stages done. Run can be completed via **astro_workflow_proceed**.`);
+                }
+                else if (next.kind === "failed") {
+                    lines.push(`- Run failed at \`${next.stage_key}\`: ${next.error_text}`);
+                }
                 if (include_board) {
-                    const counts = db
-                        .prepare("SELECT state, COUNT(*) as c FROM stories GROUP BY state ORDER BY state")
-                        .all();
+                    const counts = db.prepare("SELECT state, COUNT(*) as c FROM stories GROUP BY state ORDER BY state").all();
                     lines.push(``, `## Story board`);
                     for (const row of counts)
                         lines.push(`- ${row.state}: ${row.c}`);
                 }
+                if (include_recent_events) {
+                    const evs = db.prepare("SELECT created_at, type, run_id, stage_key FROM events ORDER BY created_at DESC LIMIT 10").all();
+                    lines.push(``, `## Recent events`);
+                    for (const e of evs)
+                        lines.push(`- ${e.created_at} — ${e.type}${e.run_id ? ` (run=${e.run_id})` : ""}${e.stage_key ? ` stage=${e.stage_key}` : ""}`);
+                }
                 return lines.join("\n");
             }
-            const story = getStory(db, active.story_key);
-            const stageRuns = getStageRuns(db, active.run_id);
-            lines.push(`- Active run: \`${active.run_id}\` ${statusIcon(active.status)} **${active.status}**`);
-            lines.push(`- Story: \`${active.story_key}\` — ${story?.title ?? "(missing)"}  (${story?.state ?? "?"})`);
-            lines.push(`- Current stage: \`${active.current_stage_key ?? "?"}\``);
-            lines.push(``, `## Pipeline`);
-            for (const s of stageRuns) {
-                lines.push(`- ${stageIcon(s.status)} \`${s.stage_key}\` (${s.status})`);
-            }
-            const next = decideNextAction(db, config);
-            lines.push(``, `## Next`);
-            lines.push(`- ${next.kind}`);
-            if (next.kind === "await_stage_completion") {
-                lines.push(`- Awaiting output for stage \`${next.stage_key}\`. When you have it, call **astro_stage_complete** with the stage output text.`);
-            }
-            else if (next.kind === "delegate_stage") {
-                lines.push(`- Need to run stage \`${next.stage_key}\`. Use **astro_workflow_proceed** (or delegate to the matching stage agent).`);
-            }
-            else if (next.kind === "complete_run") {
-                lines.push(`- All stages done. Run can be completed via **astro_workflow_proceed**.`);
-            }
-            else if (next.kind === "failed") {
-                lines.push(`- Run failed at \`${next.stage_key}\`: ${next.error_text}`);
-            }
-            if (include_board) {
-                const counts = db
-                    .prepare("SELECT state, COUNT(*) as c FROM stories GROUP BY state ORDER BY state")
-                    .all();
-                lines.push(``, `## Story board`);
-                for (const row of counts)
-                    lines.push(`- ${row.state}: ${row.c}`);
-            }
-            if (include_recent_events) {
-                const evs = db
-                    .prepare("SELECT created_at, type, run_id, stage_key FROM events ORDER BY created_at DESC LIMIT 10")
-                    .all();
-                lines.push(``, `## Recent events`);
-                for (const e of evs)
-                    lines.push(`- ${e.created_at} — ${e.type}${e.run_id ? ` (run=${e.run_id})` : ""}${e.stage_key ? ` stage=${e.stage_key}` : ""}`);
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                if (msg.includes("no such table") || msg.includes("no such column")) {
+                    return [
+                        `⚠️ Astrocode not initialized.`,
+                        ``,
+                        `- Reason: Database present but schema is not initialized or is incompatible`,
+                        `- Error: ${msg}`,
+                        ``,
+                        `Next: run **astro_init**, then restart the agent/runtime, then run /astro-status.`,
+                    ].join("\n");
+                }
+                return [
+                    `# Astrocode Status`,
+                    ``,
+                    `⛔ Database error.`,
+                    `Error: ${msg}`,
+                ].join("\n");
             }
-            return lines.join("\n");
         },
     });
 }

package/dist/tools/workflow.js

@@ -1,7 +1,7 @@
 import { tool } from "@opencode-ai/plugin/tool";
 import { withTx } from "../state/db";
 import { buildContextSnapshot } from "../workflow/context";
-import { decideNextAction, createRunForStory, startStage, completeRun, getActiveRun } from "../workflow/state-machine";
+import { decideNextAction, createRunForStory, startStage, completeRun, getActiveRun, EVENT_TYPES } from "../workflow/state-machine";
 import { buildStageDirective, directiveHash } from "../workflow/directives";
 import { injectChatPrompt } from "../ui/inject";
 import { nowISO } from "../shared/time";
@@ -318,7 +318,7 @@ export function createAstroWorkflowProceedTool(opts) {
                 break;
             }
             // Housekeeping event
-            db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, NULL, NULL, 'workflow.proceed', ?, ?)").run(newEventId(), JSON.stringify({ started_at: startedAt, mode, max_steps: steps, actions }), nowISO());
+            db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, NULL, NULL, ?, ?, ?)").run(newEventId(), EVENT_TYPES.WORKFLOW_PROCEED, JSON.stringify({ started_at: startedAt, mode, max_steps: steps, actions }), nowISO());
             const active = getActiveRun(db);
             const lines = [];
             lines.push(`# astro_workflow_proceed`);