astrocode-workflow 0.1.58 → 0.2.0

package/src/config/schema.ts

@@ -108,6 +108,8 @@ const WorkflowSchema = z.object({
     "close",
   ]),
 
+  genesis_planning: z.enum(["off", "first_story_only", "always"]).default("first_story_only"),
+
   default_mode: z.enum(["step", "loop"]).default("step"),
   default_max_steps: z.number().int().positive().default(1),
   loop_max_steps_hard_cap: z.number().int().positive().default(200),
@@ -167,6 +169,7 @@ const AgentsSchema = z.object({
 
   librarian_name: z.string().default("Librarian"),
   explore_name: z.string().default("Explore"),
+  qa_name: z.string().default("QA"),
 
   agent_variant_overrides: z
     .record(

package/src/hooks/continuation-enforcer.ts

@@ -35,12 +35,19 @@ 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;
-  db: SqliteDb;
+  runtime: RuntimeState;
 }) {
-  const { ctx, config, db } = opts;
+  const { ctx, config, runtime } = opts;
+  const { db } = runtime;
 
   const toasts = createToastManager({ ctx, throttleMs: config.ui.toasts.throttle_ms });
 

package/src/hooks/inject-provider.ts

@@ -9,12 +9,19 @@ type ChatMessageInput = {
   agent: 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;
-  db: SqliteDb;
+  runtime: RuntimeState;
 }) {
-  const { ctx, config, db } = opts;
+  const { ctx, config, runtime } = opts;
+  const { db } = runtime;
 
   // Cache to avoid re-injecting the same injects repeatedly
   const injectedCache = new Map<string, number>();

package/src/hooks/tool-output-truncator.ts

@@ -25,12 +25,19 @@ function pickMaxChars(toolName: string, cfg: AstrocodeConfig): number {
   return cfg.truncation.max_chars_default;
 }
 
+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 createToolOutputTruncatorHook(opts: {
   ctx: any;
   config: AstrocodeConfig;
-  db: SqliteDb;
+  runtime: RuntimeState;
 }) {
-  const { ctx, config, db } = opts;
+  const { ctx, config, runtime } = opts;
+  const { db } = runtime;
 
   return async function toolExecuteAfter(input: ToolExecuteAfterInput, output: ToolExecuteAfterOutput) {
     if (!config.truncation.enabled) return;

package/src/index.ts

@@ -1,72 +1,257 @@
 import type { Plugin } from "@opencode-ai/plugin";
 import { loadAstrocodeConfig } from "./config/loader";
+import type { AstrocodeConfig } from "./config/schema";
 import { createConfigHandler } from "./config/config-handler";
-import { openSqlite, configurePragmas, ensureSchema } from "./state/db";
+import { openSqlite, configurePragmas, ensureSchema, getSchemaVersion } from "./state/db";
+import type { SqliteDb } from "./state/db";
 import { getAstroPaths, ensureAstroDirs } from "./shared/paths";
 import { createAstroTools } from "./tools";
 import { createContinuationEnforcer } from "./hooks/continuation-enforcer";
 import { createToolOutputTruncatorHook } from "./hooks/tool-output-truncator";
 import { createInjectProvider } from "./hooks/inject-provider";
-import { createToastManager } from "./ui/toasts";
+import { createToastManager, type ToastOptions } from "./ui/toasts";
 import { createAstroAgents } from "./agents/registry";
+import type { AgentConfig } from "@opencode-ai/sdk";
 import { info, warn } from "./shared/log";
 
+// Type definitions for plugin components
+type ConfigHandler = (config: Record<string, any>) => Promise<void>;
+type ContinuationEnforcer = {
+  onToolAfter: (input: any) => Promise<void>;
+  onChatMessage: (input: any) => Promise<void>;
+  onEvent: (input: any) => Promise<void>;
+};
+type ToolOutputTruncator = (input: any, output: any | null) => Promise<void>;
+type InjectProvider = {
+  onChatMessage: (input: any) => Promise<void>;
+};
+type ToastManager = {
+  show: (toast: ToastOptions) => Promise<void>;
+};
+
+// Hook names for type safety
+type HookKey = "continuation-enforcer" | "tool-output-truncator" | "inject-provider";
+
+// Safe config cloning with structuredClone preference (fallback for older Node versions)
+// CONTRACT: Config is guaranteed JSON-serializable (enforced by loadAstrocodeConfig validation)
+const cloneConfig = <T>(v: T): T => {
+  // Prefer structuredClone when available (keeps more types)
+  if (typeof (globalThis as any).structuredClone === "function") {
+    return (globalThis as any).structuredClone(v);
+  }
+  // Fallback: JSON clone (safe since config is validated as JSON-serializable)
+  return JSON.parse(JSON.stringify(v));
+};
+
+// Minimal config defaults for limited-mode fallback
+const applyMinimalConfigDefaults = (cfg: Record<string, any>) => {
+  if (!cfg || typeof cfg !== "object") return;
+  if (!Array.isArray((cfg as any).disabled_hooks)) (cfg as any).disabled_hooks = [];
+  if (!(cfg as any).ui || typeof (cfg as any).ui !== "object") (cfg as any).ui = {};
+  if (!(cfg as any).ui.toasts || typeof (cfg as any).ui.toasts !== "object") (cfg as any).ui.toasts = { enabled: false };
+  if (typeof (cfg as any).ui.toasts.enabled !== "boolean") (cfg as any).ui.toasts.enabled = false;
+};
+
 const Astrocode: Plugin = async (ctx) => {
-  const repoRoot = ctx.directory as string;
+  if (!ctx.directory || typeof ctx.directory !== "string") {
+    throw new Error("Astrocode requires ctx.directory to be a string repo root.");
+  }
+  const repoRoot = ctx.directory;
 
   // Always load config first - this provides defaults even in limited mode
-  let pluginConfig = loadAstrocodeConfig(repoRoot);
-
-  // Create agents for registration
-  const agents = createAstroAgents({ pluginConfig });
+  let pluginConfig: AstrocodeConfig;
+  try {
+    pluginConfig = loadAstrocodeConfig(repoRoot);
+   } catch (e) {
+     warn(`Config loading failed, using minimal defaults.`, { err: e });
+     // Fallback to minimal safe defaults when config loading fails
+    pluginConfig = {
+      disabled_hooks: [],
+      disabled_agents: [],
+      determinism: { mode: "on" as const, strict_stage_order: true },
+      db: {
+        path: ".astro/astro.db",
+        busy_timeout_ms: 5000,
+        pragmas: {},
+        schema_version_required: 2,
+        allow_auto_migrate: true,
+        fail_on_downgrade: true,
+      },
+      ui: {
+        toasts: { enabled: true, throttle_ms: 1500, show_run_started: true, show_stage_started: true, show_stage_completed: true, show_stage_failed: true, show_run_completed: true, show_auto_continue: true },
+      },
+      agents: {
+        orchestrator_name: "Astro",
+        stage_agent_names: { frame: "Frame", plan: "Plan", spec: "Spec", implement: "Implement", review: "Review", verify: "Verify", close: "Close" },
+        librarian_name: "Librarian",
+        explore_name: "Explore",
+        qa_name: "QA",
+        agent_variant_overrides: {},
+      },
+      workflow: {
+        default_mode: "step" as const,
+        default_max_steps: 10,
+        loop_max_steps_hard_cap: 100,
+        evidence_required: { verify: false },
+      },
+      permissions: { enforce_task_tool_restrictions: false, deny_delegate_task_in_subagents: false },
+    };
+  }
 
   // Always ensure .astro directories exist, even in limited mode
   const paths = getAstroPaths(repoRoot, pluginConfig.db.path);
   ensureAstroDirs(paths);
 
-  let db: any = null;
-  let tools: any = null;
-    let configHandler: any = null;
-    let continuation: any = null;
-    let truncatorHook: any = null;
-    let injectProvider: any = null;
-    let toasts: any = null;
+  let db: SqliteDb | null = null;
+  let agents: Record<string, AgentConfig> | undefined = undefined;
+  let configHandler: ConfigHandler = async () => {
+    throw new Error("ConfigHandler called before initialization");
+  };
+  let continuation: ContinuationEnforcer | null = null;
+  let truncatorHook: ToolOutputTruncator | null = null;
+  let injectProvider: InjectProvider | null = null;
+  let toastManager: ToastManager | null = null;
+   let limitedModeReason: null | { code: "db_init_failed"|"schema_too_old"|"schema_downgrade"|"schema_migration_failed"; details: any } = null;
+   let limitedMode = false;
 
+  // Phase 1: Database initialization (only DB-related operations)
   try {
-
     db = openSqlite(paths.dbPath, { busyTimeoutMs: pluginConfig.db.busy_timeout_ms });
     configurePragmas(db, pluginConfig.db.pragmas);
-    ensureSchema(db, { allowAutoMigrate: pluginConfig.db.allow_auto_migrate, failOnDowngrade: pluginConfig.db.fail_on_downgrade });
-
-    // Database initialized successfully
-    configHandler = createConfigHandler({ pluginConfig });
-    tools = createAstroTools({ ctx, config: pluginConfig, db, agents });
-    continuation = createContinuationEnforcer({ ctx, config: pluginConfig, db });
-    truncatorHook = createToolOutputTruncatorHook({ ctx, config: pluginConfig, db });
-    injectProvider = createInjectProvider({ ctx, config: pluginConfig, db });
-    toasts = createToastManager({ ctx, throttleMs: pluginConfig.ui.toasts.throttle_ms });
-  } catch (e) {
-    // Database initialization failed - setup limited mode
-
-    // Reload config to ensure all defaults are present
-    pluginConfig = loadAstrocodeConfig(repoRoot);
+    // Policy enforced in harness; db layer is mechanics only (migration + structural schema creation)
+     ensureSchema(db, { allowAutoMigrate: pluginConfig.db.allow_auto_migrate });
+
+    // Harness-exclusive: enforce schema version requirement
+
+    // Explicitly enforce schema version requirement (harness-level policy)
+    const required = pluginConfig.db.schema_version_required;
+    let current = getSchemaVersion(db);
+
+    if (current < required) {
+      if (!pluginConfig.db.allow_auto_migrate) {
+        // Migration disabled - enter limited mode
+        limitedModeReason = { code: "schema_too_old", details: { current, required } };
+        warn("Entering limited mode (schema too old, migration disabled).", {
+          dbPath: paths.dbPath,
+          schemaCurrent: current,
+          schemaRequired: required,
+          failOnDowngrade: pluginConfig.db.fail_on_downgrade,
+          allowAutoMigrate: pluginConfig.db.allow_auto_migrate,
+        });
+        db.close?.();
+        db = null;
+      } else {
+        // Migration allowed - re-run ensureSchema (idempotent) in case first call failed
+        ensureSchema(db, { allowAutoMigrate: true });
+        current = getSchemaVersion(db);
 
-    // Modify config for limited mode
-    pluginConfig.disabled_hooks = [...(pluginConfig.disabled_hooks || []), "continuation-enforcer", "tool-output-truncator"];
+        if (current < required) {
+          // Migration failed - enter limited mode
+          limitedModeReason = { code: "schema_migration_failed", details: { current, required } };
+          warn("Entering limited mode (schema migration failed).", {
+            dbPath: paths.dbPath,
+            schemaCurrent: current,
+            schemaRequired: required,
+            failOnDowngrade: pluginConfig.db.fail_on_downgrade,
+            allowAutoMigrate: pluginConfig.db.allow_auto_migrate,
+          });
+          db.close?.();
+          db = null;
+        }
+      }
+    } else if (current > required && pluginConfig.db.fail_on_downgrade) {
+      limitedModeReason = { code: "schema_downgrade", details: { current, required } };
+      warn("Entering limited mode (schema downgrade).", {
+        dbPath: paths.dbPath,
+        schemaCurrent: current,
+        schemaRequired: required,
+        failOnDowngrade: pluginConfig.db.fail_on_downgrade,
+        allowAutoMigrate: pluginConfig.db.allow_auto_migrate,
+      });
+      db.close?.();
+      db = null;
+    }
+   } catch (e) {
+     // True database initialization failure - enter limited mode
+     warn(`Database initialization failed. Entering limited mode with reduced functionality.`, { err: e });
+     // Clean up partially-opened database connection
+     if (db && typeof db.close === "function") {
+       try {
+         db.close();
+       } catch (closeErr) {
+         // Ignore close errors during cleanup
+       }
+     }
+     db = null;
+     limitedModeReason = { code: "db_init_failed", details: e };
+   }
+
+    // Derive limited mode flag once for single source of truth
+    limitedMode = db === null;
+
+    // Single runtime state object for downstream components
+    const runtime = { db, limitedMode, limitedModeReason };
+
+    // Phase 2: Component initialization (based on DB availability)
+   if (!limitedMode) {
+    // Normal mode: DB available, create all components
+    try {
+      agents = createAstroAgents({ pluginConfig });
+
+      // Database initialized successfully
+      info("Database initialized successfully. Plugin ready.");
+       configHandler = createConfigHandler({ pluginConfig });
+        continuation = createContinuationEnforcer({ ctx, config: pluginConfig, runtime });
+        truncatorHook = createToolOutputTruncatorHook({ ctx, config: pluginConfig, runtime });
+        injectProvider = createInjectProvider({ ctx, config: pluginConfig, runtime });
+       toastManager = createToastManager({ ctx, throttleMs: pluginConfig.ui.toasts.throttle_ms });
+    } catch (e) {
+      // Component failure with working DB → fail plugin boot
+      const err = e instanceof Error ? e : new Error(String(e));
+      throw new Error("Plugin initialization failed after successful database setup", { cause: err });
+    }
+  } else {
+    // Limited mode: DB unavailable, create minimal components
+    // Clone the already-loaded config to avoid mutating shared state, then apply limited mode overrides
+    pluginConfig = cloneConfig(pluginConfig);
+
+    // Apply limited-mode config overrides BEFORE creating any components
+    pluginConfig.disabled_hooks = Array.from(new Set([...(pluginConfig.disabled_hooks || []), "continuation-enforcer", "tool-output-truncator", "inject-provider"]));
     pluginConfig.ui.toasts.enabled = false;
 
-    // Create limited functionality
-    db = null;
-    configHandler = createConfigHandler({ pluginConfig });
-    tools = createAstroTools({ ctx, config: pluginConfig, db, agents });
+    // Show one-shot limited mode notification via logging (keeps toast policy consistent)
+    const reasonMessage = limitedModeReason ?
+      (limitedModeReason.code === "db_init_failed" ? "Database initialization failed. Check native deps or run astro_init." :
+       limitedModeReason.code === "schema_too_old" ? "Database schema too old and migration disabled." :
+       limitedModeReason.code === "schema_downgrade" ? "Database schema newer than plugin (downgrade detected)." :
+       limitedModeReason.code === "schema_migration_failed" ? "Database schema migration failed." :
+       "Database unavailable.") :
+      "Database unavailable.";
+    warn(`Astrocode: Limited Mode - ${reasonMessage}`, { dbPath: paths.dbPath });
+
+    // Create limited functionality (no global toast manager since toasts are disabled)
+    try {
+      configHandler = createConfigHandler({ pluginConfig });
+    } catch (e) {
+      warn("Limited Mode: config handler unavailable", { err: e });
+      configHandler = async (config: Record<string, any>) => {
+        applyMinimalConfigDefaults(config);
+      };
+    }
     continuation = null;
     truncatorHook = null;
     injectProvider = null;
-    toasts = null;
+    toastManager = null; // No global toast manager in limited mode
   }
 
+  // Helper for hook enablement checks (config is now finalized)
+  const hookEnabled = (key: HookKey) => !pluginConfig.disabled_hooks?.includes(key);
+
+    // Create tools once with final state (limited mode gets DB-safe tool implementations)
+    const tools = createAstroTools({ ctx, config: pluginConfig, agents, runtime });
+
   return {
-    name: "Astrocode",
+    name: "astrocode-harness",
 
     // Register agents
     agents,
@@ -75,63 +260,82 @@ const Astrocode: Plugin = async (ctx) => {
     config: configHandler,
 
     // Register tools
-    tool: createAstroTools({ ctx, config: pluginConfig, db, agents }),
+    tool: tools,
 
     // Limit created subagents from spawning more subagents (OMO-style).
     "tool.execute.before": async (input: any, output: any) => {
       if (!pluginConfig.permissions.enforce_task_tool_restrictions) return;
-      if (input.tool !== "task") return;
-
-      output.args = output.args ?? {};
+      if (input?.tool !== "task") return;
 
-      const toolsMap = { ...(output.args.tools ?? {}) };
+      const baseArgs =
+        (output && typeof output === "object" ? (output as any).args : undefined) ?? {};
+      const baseTools =
+        (baseArgs && typeof baseArgs === "object" && (baseArgs as any).tools && typeof (baseArgs as any).tools === "object")
+          ? (baseArgs as any).tools
+          : {};
 
+      const nextTools = { ...baseTools };
       if (pluginConfig.permissions.deny_delegate_task_in_subagents) {
-        toolsMap.delegate_task = false;
+        nextTools.delegate_task = false;
       }
 
-      output.args.tools = toolsMap;
+      const nextArgs = { ...baseArgs, tools: nextTools };
+
+      // Back-compat: mutate if possible
+      if (output && typeof output === "object" && !Object.isFrozen(output)) {
+        (output as any).args = nextArgs;
+      }
+
+      // Forward-compat: return conservative merge
+      if (output && typeof output === "object") {
+        return { ...(output as any), args: nextArgs };
+      }
+      return { args: nextArgs };
     },
 
     "tool.execute.after": async (input: any, output: any) => {
       // Truncate huge tool outputs to artifacts
-      if (truncatorHook && !pluginConfig.disabled_hooks.includes("tool-output-truncator")) {
-        await truncatorHook(input, output);
+      if (truncatorHook && hookEnabled("tool-output-truncator")) {
+        await truncatorHook(input, output ?? null);
       }
 
       // Schedule continuation (do not immediately spam)
-      if (continuation && !pluginConfig.disabled_hooks.includes("continuation-enforcer")) {
+      if (continuation && hookEnabled("continuation-enforcer")) {
         await continuation.onToolAfter(input);
       }
+
+      return output;
     },
 
     "chat.message": async (input: any, output: any) => {
-      if (injectProvider && !pluginConfig.disabled_hooks.includes("inject-provider")) {
+      if (injectProvider && hookEnabled("inject-provider")) {
         await injectProvider.onChatMessage(input);
       }
-      if (continuation && !pluginConfig.disabled_hooks.includes("continuation-enforcer")) {
+      if (continuation && hookEnabled("continuation-enforcer")) {
         await continuation.onChatMessage(input);
       }
       return output;
     },
 
     event: async (input: any) => {
-      if (continuation && !pluginConfig.disabled_hooks.includes("continuation-enforcer")) {
+      if (continuation && hookEnabled("continuation-enforcer")) {
         await continuation.onEvent(input);
       }
     },
 
     // Best-effort cleanup
     close: async () => {
-      try {
-        db.close();
-      } catch {
-        // ignore
+      if (db && typeof db.close === "function") {
+        try {
+          db.close();
+        } catch {
+          // ignore
+        }
       }
 
-      if (toasts && pluginConfig.ui.toasts.enabled) {
+      if (toastManager && pluginConfig.ui.toasts.enabled) {
         try {
-          await toasts.show({ title: "Astrocode", message: "Plugin closed", variant: "info" });
+          await toastManager.show({ title: "Astrocode", message: "Plugin closed", variant: "info" });
         } catch {
           // ignore
         }

package/src/state/adapters/index.ts

@@ -18,27 +18,18 @@ export interface DatabaseAdapter {
   open(path: string, opts?: { busyTimeoutMs?: number }): DatabaseConnection;
 }
 
-// Mock adapter for when no database is available
-export class MockDatabaseAdapter implements DatabaseAdapter {
+// Null adapter for when no database driver is available
+export class NullAdapter implements DatabaseAdapter {
   isAvailable(): boolean {
-    return true; // Mock is always available
+    return false;
   }
 
-  open(): DatabaseConnection {
-    warn("Using mock database - no persistence available");
-    return {
-      pragma: () => {},
-      exec: () => {},
-      prepare: () => ({
-        run: () => ({ changes: 0, lastInsertRowid: null }),
-        get: () => null,
-        all: () => []
-      }),
-      close: () => {}
-    };
+  open(path: string, opts?: { busyTimeoutMs?: number }): DatabaseConnection {
+    throw new Error("No SQLite driver available");
   }
 }
 
+
 // Bun SQLite adapter - singleton pattern to avoid multiple initializations
 let bunDatabase: any = null;
 let bunDatabaseInitialized = false;
@@ -127,7 +118,7 @@ export class BetterSqliteAdapter implements DatabaseAdapter {
     }
 
     return {
-      pragma: (sql: string) => db.pragma(sql.replace('PRAGMA ', '')),
+      pragma: (sql: string) => db.pragma(sql),
       exec: (sql: string) => db.exec(sql),
       prepare: (sql: string) => db.prepare(sql),
       close: () => db.close()
@@ -140,16 +131,20 @@ export function createDatabaseAdapter(): DatabaseAdapter {
   const isBun = typeof (globalThis as any).Bun !== 'undefined';
 
   if (isBun) {
-    const adapter = new BunSqliteAdapter();
-    if (adapter.isAvailable()) {
-      return adapter;
-    }
-    throw new Error("Bun runtime detected but bun:sqlite not available");
+    // Prefer bun:sqlite in Bun runtime
+    const bunAdapter = new BunSqliteAdapter();
+    if (bunAdapter.isAvailable()) return bunAdapter;
+    // Fallback to better-sqlite3
+    const betterAdapter = new BetterSqliteAdapter();
+    if (betterAdapter.isAvailable()) return betterAdapter;
   } else {
-    const adapter = new BetterSqliteAdapter();
-    if (adapter.isAvailable()) {
-      return adapter;
-    }
-    throw new Error("Node.js runtime detected but better-sqlite3 not available");
+    // Prefer better-sqlite3 in Node.js
+    const betterAdapter = new BetterSqliteAdapter();
+    if (betterAdapter.isAvailable()) return betterAdapter;
+    // Fallback to bun:sqlite (rare but possible)
+    const bunAdapter = new BunSqliteAdapter();
+    if (bunAdapter.isAvailable()) return bunAdapter;
   }
+
+  return new NullAdapter();
 }