astrocode-workflow 0.4.0 → 0.4.2

package/src/index.ts

@@ -24,6 +24,7 @@ type ContinuationEnforcer = {
 type ToolOutputTruncator = (input: any, output: any | null) => Promise<void>;
 type InjectProvider = {
   onChatMessage: (input: any) => Promise<void>;
+  onToolAfter: (input: any) => Promise<void>;
 };
 type ToastManager = {
   show: (toast: ToastOptions) => Promise<void>;
@@ -294,6 +295,11 @@ const Astrocode: Plugin = async (ctx) => {
     },
 
     "tool.execute.after": async (input: any, output: any) => {
+      // Inject eligible injects after tool execution (not just on chat messages)
+      if (injectProvider && hookEnabled("inject-provider")) {
+        await injectProvider.onToolAfter(input);
+      }
+
       // Truncate huge tool outputs to artifacts
       if (truncatorHook && hookEnabled("tool-output-truncator")) {
         await truncatorHook(input, output ?? null);
@@ -325,6 +331,7 @@ const Astrocode: Plugin = async (ctx) => {
 
     // Best-effort cleanup
     close: async () => {
+      // Close database connection
       if (db && typeof db.close === "function") {
         try {
           db.close();

package/src/shared/metrics.ts

@@ -0,0 +1,148 @@
+// src/shared/metrics.ts
+
+export interface TransactionMetrics {
+  startTime: number;
+  duration: number;
+  success: boolean;
+  nestedDepth: number;
+  operation?: string;
+}
+
+export interface InjectionMetrics {
+  sessionId: string;
+  attempts: number;
+  duration: number;
+  success: boolean;
+  agent?: string;
+}
+
+export interface SystemMetrics {
+  transactions: TransactionMetrics[];
+  injections: InjectionMetrics[];
+  errors: Array<{ type: string; message: string; timestamp: number }>;
+}
+
+class MetricsCollector {
+  private transactions: TransactionMetrics[] = [];
+  private injections: InjectionMetrics[] = [];
+  private errors: Array<{ type: string; message: string; timestamp: number }> = [];
+  private maxEntries = 1000; // Keep last 1000 entries per type
+
+  recordTransaction(metrics: TransactionMetrics) {
+    this.transactions.push(metrics);
+    if (this.transactions.length > this.maxEntries) {
+      this.transactions.shift();
+    }
+  }
+
+  recordInjection(metrics: InjectionMetrics) {
+    this.injections.push(metrics);
+    if (this.injections.length > this.maxEntries) {
+      this.injections.shift();
+    }
+  }
+
+  recordError(type: string, message: string) {
+    this.errors.push({ type, message, timestamp: Date.now() });
+    if (this.errors.length > this.maxEntries) {
+      this.errors.shift();
+    }
+  }
+
+  getMetrics(): SystemMetrics {
+    return {
+      transactions: [...this.transactions],
+      injections: [...this.injections],
+      errors: [...this.errors],
+    };
+  }
+
+  getTransactionStats() {
+    const txs = this.transactions;
+    if (txs.length === 0) return null;
+
+    const successful = txs.filter(t => t.success);
+    const failed = txs.filter(t => !t.success);
+
+    return {
+      total: txs.length,
+      successful: successful.length,
+      failed: failed.length,
+      successRate: successful.length / txs.length,
+      avgDuration: txs.reduce((sum, t) => sum + t.duration, 0) / txs.length,
+      avgNestedDepth: txs.reduce((sum, t) => sum + t.nestedDepth, 0) / txs.length,
+      minDuration: Math.min(...txs.map(t => t.duration)),
+      maxDuration: Math.max(...txs.map(t => t.duration)),
+    };
+  }
+
+  getInjectionStats() {
+    const injections = this.injections;
+    if (injections.length === 0) return null;
+
+    const successful = injections.filter(i => i.success);
+    const failed = injections.filter(i => !i.success);
+
+    return {
+      total: injections.length,
+      successful: successful.length,
+      failed: failed.length,
+      successRate: successful.length / injections.length,
+      avgAttempts: injections.reduce((sum, i) => sum + i.attempts, 0) / injections.length,
+      avgDuration: injections.reduce((sum, i) => sum + i.duration, 0) / injections.length,
+      totalRetries: injections.reduce((sum, i) => sum + Math.max(0, i.attempts - 1), 0),
+    };
+  }
+
+  clear() {
+    this.transactions = [];
+    this.injections = [];
+    this.errors = [];
+  }
+}
+
+// Global singleton
+export const metrics = new MetricsCollector();
+
+// Convenience functions
+export function recordTransaction(metricsData: Omit<TransactionMetrics, 'startTime' | 'duration' | 'success'>) {
+  return {
+    start() {
+      return {
+        ...metricsData,
+        startTime: Date.now(),
+      };
+    },
+    end(startData: ReturnType<ReturnType<typeof recordTransaction>['start']>, success: boolean) {
+      const duration = Date.now() - startData.startTime;
+      metrics.recordTransaction({
+        ...startData,
+        duration,
+        success,
+      });
+    },
+  };
+}
+
+export function recordInjection(metricsData: Omit<InjectionMetrics, 'duration' | 'success'>) {
+  return {
+    start() {
+      return {
+        ...metricsData,
+        startTime: Date.now(),
+      };
+    },
+    end(startData: any, success: boolean) {
+      const duration = Date.now() - startData.startTime;
+      metrics.recordInjection({
+        ...startData,
+        duration,
+        success,
+      });
+    },
+  };
+}
+
+export function recordError(type: string, message: string) {
+  metrics.recordError(type, message);
+}

package/src/state/db.ts

@@ -5,6 +5,7 @@ import { SCHEMA_SQL, SCHEMA_VERSION } from "./schema";
 import { nowISO } from "../shared/time";
 import { info, warn } from "../shared/log";
 import { createDatabaseAdapter, DatabaseConnection } from "./adapters";
+import { recordTransaction } from "../shared/metrics";
 
 export type SqliteDb = DatabaseConnection;
 
@@ -74,7 +75,7 @@ function savepointName(depth: number): string {
 }
 
 /** BEGIN IMMEDIATE transaction helper (re-entrant). */
-export function withTx<T>(db: SqliteDb, fn: () => T, opts?: { require?: boolean }): T {
+export function withTx<T>(db: SqliteDb, fn: () => T, opts?: { require?: boolean; operation?: string }): T {
   const adapter = createDatabaseAdapter();
   const available = adapter.isAvailable();
 
@@ -84,13 +85,17 @@ export function withTx<T>(db: SqliteDb, fn: () => T, opts?: { require?: boolean
   }
 
   const depth = getDepth(db);
+  const isNested = depth > 0;
+  const txRecorder = recordTransaction({ nestedDepth: depth, operation: opts?.operation });
 
   if (depth === 0) {
+    const txStart = txRecorder.start();
     db.exec("BEGIN IMMEDIATE");
     setDepth(db, 1);
     try {
       const out = fn();
       db.exec("COMMIT");
+      txRecorder.end(txStart, true);
       return out;
     } catch (e) {
       try {
@@ -98,6 +103,7 @@ export function withTx<T>(db: SqliteDb, fn: () => T, opts?: { require?: boolean
       } catch {
         // ignore
       }
+      txRecorder.end(txStart, false);
       throw e;
     } finally {
       setDepth(db, 0);
@@ -107,6 +113,7 @@ export function withTx<T>(db: SqliteDb, fn: () => T, opts?: { require?: boolean
   // Nested: use SAVEPOINT
   const nextDepth = depth + 1;
   const sp = savepointName(nextDepth);
+  const txStart = txRecorder.start();
 
   db.exec(`SAVEPOINT ${sp}`);
   setDepth(db, nextDepth);
@@ -114,6 +121,7 @@ export function withTx<T>(db: SqliteDb, fn: () => T, opts?: { require?: boolean
   try {
     const out = fn();
     db.exec(`RELEASE SAVEPOINT ${sp}`);
+    txRecorder.end(txStart, true);
     return out;
   } catch (e) {
     try {
@@ -126,6 +134,7 @@ export function withTx<T>(db: SqliteDb, fn: () => T, opts?: { require?: boolean
     } catch {
       // ignore
     }
+    txRecorder.end(txStart, false);
     throw e;
   } finally {
     setDepth(db, depth);

package/src/state/schema.ts

@@ -4,7 +4,7 @@
 //
 // Source of truth: SQLite file at .astro/astro.db
 
-export const SCHEMA_VERSION = 2;
+export const SCHEMA_VERSION = 3; // v3: Added advisory lock support + database constraints
 
 export const SCHEMA_SQL = `
 PRAGMA foreign_keys = ON;
@@ -235,6 +235,13 @@ CREATE INDEX IF NOT EXISTS idx_artifacts_run_stage ON artifacts(run_id, stage_ke
 CREATE INDEX IF NOT EXISTS idx_events_run ON events(run_id, created_at DESC);
 CREATE INDEX IF NOT EXISTS idx_tool_runs_run ON tool_runs(run_id, created_at DESC);
 CREATE INDEX IF NOT EXISTS idx_injects_scope_priority ON injects(scope, priority DESC, created_at DESC);
+
+-- CONSTRAINT: Only one running run at a time (partial unique index)
+-- This provides database-level safety when using advisory locks
+CREATE UNIQUE INDEX IF NOT EXISTS idx_single_running_run ON runs(status) WHERE status = 'running';
+
+-- CONSTRAINT: Only one run can lock a story at a time (partial unique index)
+CREATE UNIQUE INDEX IF NOT EXISTS idx_single_story_lock ON stories(in_progress) WHERE in_progress = 1;
 CREATE INDEX IF NOT EXISTS idx_injects_scope_type_priority_updated ON injects(scope, type, priority DESC, updated_at DESC);
 CREATE INDEX IF NOT EXISTS idx_injects_expires ON injects(expires_at) WHERE expires_at IS NOT NULL;
 CREATE INDEX IF NOT EXISTS idx_injects_sha256 ON injects(sha256) WHERE sha256 IS NOT NULL;

package/src/tools/health.ts

@@ -0,0 +1,99 @@
+// src/tools/health.ts
+import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+import { getSchemaVersion } from "../state/db";
+import { getActiveRun } from "../workflow/state-machine";
+import fs from "node:fs";
+import path from "node:path";
+
+export function createAstroHealthTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
+  const { ctx, config, db } = opts;
+
+  return tool({
+    description: "Check Astrocode health: DB status, locks, schema, active runs, recent events.",
+    args: {},
+    execute: async () => {
+      const lines: string[] = [];
+      const repoRoot = (ctx as any).directory || process.cwd();
+      const dbPath = config.db?.path || ".astro/astro.db";
+      const fullDbPath = path.resolve(repoRoot, dbPath);
+
+      // System info
+      lines.push("# Astrocode Health Check");
+      lines.push(`- PID: ${(process as any).pid || "unknown"}`);
+      lines.push(`- Repo: ${repoRoot}`);
+      lines.push(`- DB Path: ${fullDbPath}`);
+
+      // DB file status
+      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`);
+        return lines.join("\n");
+      }
+
+      // Schema version
+      try {
+        const schemaVersion = getSchemaVersion(db);
+        lines.push(`- Schema Version: ${schemaVersion}`);
+      } catch (e) {
+        lines.push(`- Schema Version: ERROR (${String(e)})`);
+        lines.push(`- STATUS: DB CORRUPTED`);
+        return lines.join("\n");
+      }
+
+      // Active run
+      try {
+        const activeRun = getActiveRun(db);
+        if (activeRun) {
+          lines.push(`- Active Run: ${activeRun.run_id} (${activeRun.status})`);
+          lines.push(`  - Story: ${activeRun.story_key}`);
+          lines.push(`  - Stage: ${activeRun.current_stage_key || "none"}`);
+          lines.push(`  - Started: ${activeRun.started_at}`);
+        } else {
+          lines.push(`- Active Run: NONE`);
+        }
+      } catch (e) {
+        lines.push(`- Active Run: ERROR (${String(e)})`);
+      }
+
+      // Recent events
+      try {
+        const events = db.prepare(`
+          SELECT event_id, run_id, stage_key, type, created_at
+          FROM events
+          ORDER BY created_at DESC
+          LIMIT 10
+        `).all() as any[];
+
+        lines.push(`- Recent Events (${events.length}):`);
+        for (const event of events) {
+          const stage = event.stage_key ? `/${event.stage_key}` : "";
+          lines.push(`  - ${event.created_at}: ${event.type} (${event.run_id || "global"}${stage})`);
+        }
+      } catch (e) {
+        lines.push(`- Recent Events: ERROR (${String(e)})`);
+      }
+
+      // Status summary
+      lines.push(``);
+      lines.push(`## Status`);
+      lines.push(`✅ DB accessible`);
+      lines.push(`✅ Schema valid`);
+
+      if (walExists || shmExists) {
+        lines.push(`⚠️ WAL/SHM files present - indicates unclean shutdown or active transaction`);
+      }
+
+      return lines.join("\n");
+    },
+  });
+}

package/src/tools/index.ts

@@ -12,6 +12,9 @@ import { createAstroStageStartTool, createAstroStageCompleteTool, createAstroSta
 import { createAstroArtifactPutTool, createAstroArtifactListTool, createAstroArtifactGetTool } from "./artifacts";
 import { createAstroInjectPutTool, createAstroInjectListTool, createAstroInjectSearchTool, createAstroInjectGetTool, createAstroInjectEligibleTool, createAstroInjectDebugDueTool } from "./injects";
 import { createAstroRepairTool } from "./repair";
+import { createAstroHealthTool } from "./health";
+import { createAstroResetTool } from "./reset";
+import { createAstroMetricsTool } from "./metrics";
 
 import { AgentConfig } from "@opencode-ai/sdk";
 
@@ -35,9 +38,12 @@ export function createAstroTools(opts: CreateAstroToolsOptions): Record<string,
 
   const tools: Record<string, ToolDefinition> = {};
 
-   // Always available tools (work without database - guaranteed DB-independent)
-    tools.astro_status = createAstroStatusTool({ ctx, config });
-    tools.astro_spec_get = createAstroSpecGetTool({ ctx, config });
+    // Always available tools (work without database - guaranteed DB-independent)
+     tools.astro_status = createAstroStatusTool({ ctx, config });
+     tools.astro_spec_get = createAstroSpecGetTool({ ctx, config });
+     tools.astro_health = createAstroHealthTool({ ctx, config, db });
+     tools.astro_reset = createAstroResetTool({ ctx, config, db });
+      tools.astro_metrics = createAstroMetricsTool({ ctx, config });
 
    // Recovery tool - available even in limited mode to allow DB initialization
    tools.astro_init = createAstroInitTool({ ctx, config, runtime });
@@ -100,6 +106,9 @@ export function createAstroTools(opts: CreateAstroToolsOptions): Record<string,
     ["_astro_inject_eligible", "astro_inject_eligible"],
     ["_astro_inject_debug_due", "astro_inject_debug_due"],
     ["_astro_repair", "astro_repair"],
+     ["_astro_health", "astro_health"],
+     ["_astro_reset", "astro_reset"],
+      ["_astro_metrics", "astro_metrics"],
   ];
 
   // Only add aliases for tools that exist

package/src/tools/init.ts

@@ -8,6 +8,7 @@ import { getAstroPaths, ensureAstroDirs } from "../shared/paths";
 import { nowISO } from "../shared/time";
 import { sha256Hex } from "../shared/hash";
 
+
 type RuntimeState = {
   db: SqliteDb | null;
   limitedMode: boolean;
@@ -29,14 +30,14 @@ export function createAstroInitTool(opts: { ctx: any; config: AstrocodeConfig; r
     },
     execute: async ({ ensure_spec, spec_placeholder }) => {
       const repoRoot = ctx.directory as string;
-      const paths = getAstroPaths(repoRoot, config.db.path);
-      ensureAstroDirs(paths);
+          const paths = getAstroPaths(repoRoot, config.db.path);
+          ensureAstroDirs(paths);
 
-      const hadDbAlready = !!runtime.db;
-      let db: SqliteDb | null = runtime.db;
-      let publishedToRuntime = false;
+          const hadDbAlready = !!runtime.db;
+          let db: SqliteDb | null = runtime.db;
+          let publishedToRuntime = false;
 
-      try {
+          try {
         if (!db) {
           try {
             db = openSqlite(paths.dbPath, { busyTimeoutMs: config.db.busy_timeout_ms });

package/src/tools/metrics.ts

@@ -0,0 +1,71 @@
+// src/tools/metrics.ts
+import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
+import { metrics } from "../shared/metrics";
+
+type CreateAstroMetricsToolOptions = {
+  ctx: any;
+  config: any;
+};
+
+export function createAstroMetricsTool(opts: CreateAstroMetricsToolOptions): ToolDefinition {
+  return tool({
+    description: "Get performance metrics for Astrocode operations including transaction times, injection success rates, and error statistics.",
+    args: {},
+    execute: async () => {
+      return runMetricsTool();
+    },
+  });
+}
+
+function runMetricsTool(): string {
+  const stats = metrics.getMetrics();
+  const txStats = metrics.getTransactionStats();
+  const injectionStats = metrics.getInjectionStats();
+
+  let output = "# Astrocode Performance Metrics\n\n";
+
+  // Transaction Stats
+  if (txStats) {
+    output += "## Database Transactions\n\n";
+    output += `**Total:** ${txStats.total}\n`;
+    output += `**Success Rate:** ${(txStats.successRate * 100).toFixed(1)}% (${txStats.successful}/${txStats.total})\n`;
+    output += `**Average Duration:** ${txStats.avgDuration.toFixed(2)}ms\n`;
+    output += `**Duration Range:** ${txStats.minDuration}ms - ${txStats.maxDuration}ms\n`;
+    output += `**Average Nesting Depth:** ${txStats.avgNestedDepth.toFixed(1)}\n\n`;
+  } else {
+    output += "## Database Transactions\n\nNo transaction data available.\n\n";
+  }
+
+  // Injection Stats
+  if (injectionStats) {
+    output += "## UI Injections\n\n";
+    output += `**Total:** ${injectionStats.total}\n`;
+    output += `**Success Rate:** ${(injectionStats.successRate * 100).toFixed(1)}% (${injectionStats.successful}/${injectionStats.total})\n`;
+    output += `**Average Attempts:** ${injectionStats.avgAttempts.toFixed(1)}\n`;
+    output += `**Total Retries:** ${injectionStats.totalRetries}\n`;
+    output += `**Average Duration:** ${injectionStats.avgDuration.toFixed(2)}ms\n\n`;
+  } else {
+    output += "## UI Injections\n\nNo injection data available.\n\n";
+  }
+
+  // Recent Errors
+  if (stats.errors.length > 0) {
+    output += "## Recent Errors\n\n";
+    const recentErrors = stats.errors.slice(-10); // Last 10 errors
+    for (const error of recentErrors) {
+      const timestamp = new Date(error.timestamp).toISOString();
+      output += `- **[${error.type}]** ${timestamp}: ${error.message}\n`;
+    }
+    output += "\n";
+  } else {
+    output += "## Recent Errors\n\nNo errors recorded.\n\n";
+  }
+
+  // Raw Data Summary
+  output += "## Data Summary\n\n";
+  output += `**Transactions Tracked:** ${stats.transactions.length}\n`;
+  output += `**Injections Tracked:** ${stats.injections.length}\n`;
+  output += `**Errors Recorded:** ${stats.errors.length}\n`;
+
+  return output;
+}

package/src/tools/repair.ts

@@ -1,3 +1,4 @@
+import path from "node:path";
 import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
 import type { AstrocodeConfig } from "../config/schema";
 import type { SqliteDb } from "../state/db";
@@ -6,6 +7,7 @@ import { repairState, formatRepairReport } from "../workflow/repair";
 import { putArtifact } from "../workflow/artifacts";
 import { nowISO } from "../shared/time";
 
+
 export function createAstroRepairTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
   const { ctx, config, db } = opts;
 
@@ -16,16 +18,18 @@ export function createAstroRepairTool(opts: { ctx: any; config: AstrocodeConfig;
     },
     execute: async ({ write_report_artifact }) => {
       const repoRoot = ctx.directory as string;
+
+      // Repair database state
       const report = withTx(db, () => repairState(db, config));
-      const md = formatRepairReport(report);
+      const fullMd = formatRepairReport(report);
 
       if (write_report_artifact) {
         const rel = `.astro/repair/repair_${nowISO().replace(/[:.]/g, "-")}.md`;
-        const a = putArtifact({ repoRoot, db, run_id: null, stage_key: null, type: "log", rel_path: rel, content: md, meta: { kind: "repair" } });
-        return md + `\n\nReport saved: ${rel} (artifact=${a.artifact_id})`;
+        const a = putArtifact({ repoRoot, db, run_id: null, stage_key: null, type: "log", rel_path: rel, content: fullMd, meta: { kind: "repair" } });
+        return fullMd + `\n\nReport saved: ${rel} (artifact=${a.artifact_id})`;
       }
 
-      return md;
+      return fullMd;
     },
   });
 }

package/src/tools/reset.ts

@@ -0,0 +1,100 @@
+// src/tools/reset.ts
+import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+import fs from "node:fs";
+import path from "node:path";
+
+export function createAstroResetTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
+  const { ctx, config, db } = opts;
+
+  return tool({
+    description: "Reset Astrocode database: safely delete all DB files and WAL/SHM after killing concurrent processes.",
+    args: {
+      confirm: tool.schema.string().default("").describe("Type 'RESET' to confirm destructive operation"),
+    },
+    execute: async ({ confirm }) => {
+      if (confirm !== "RESET") {
+        return [
+          "❌ Reset cancelled - confirmation required",
+          "",
+          "This operation will:",
+          "- Delete .astro/astro.db",
+          "- Delete .astro/astro.db-wal (if exists)",
+          "- Delete .astro/astro.db-shm (if exists)",
+          "- Lose all workflow data, stories, runs, artifacts",
+          "",
+          "To confirm: astro_reset(confirm=\"RESET\")",
+        ].join("\n");
+      }
+
+      const repoRoot = (ctx as any).directory || process.cwd();
+      const dbPath = config.db?.path || ".astro/astro.db";
+      const fullDbPath = path.resolve(repoRoot, dbPath);
+
+      const lines: string[] = [];
+      lines.push("🗑️ Astrocode Database Reset");
+      lines.push(`- Repo: ${repoRoot}`);
+      lines.push(`- Target: ${fullDbPath}`);
+
+      // Check for lock file
+      const lockPath = `${repoRoot}/.astro/astro.lock`;
+      if (fs.existsSync(lockPath)) {
+        try {
+          const lockContent = fs.readFileSync(lockPath, "utf8").trim();
+          const pid = parseInt(lockContent.split(" ")[0]);
+
+          lines.push(`- Lock file found for PID ${pid}`);
+
+          // Try to kill the process
+          try {
+            (process as any).kill(pid, 'SIGTERM');
+            lines.push(`- Sent SIGTERM to PID ${pid}, waiting 2s...`);
+            await new Promise(resolve => setTimeout(resolve, 2000));
+          } catch (e) {
+            lines.push(`- Could not kill PID ${pid}: ${String(e)}`);
+          }
+        } catch (e) {
+          lines.push(`- Error reading lock file: ${String(e)}`);
+        }
+      }
+
+      // Delete DB files
+      const filesToDelete = [
+        fullDbPath,
+        `${fullDbPath}-wal`,
+        `${fullDbPath}-shm`,
+        lockPath,
+      ];
+
+      let deletedCount = 0;
+      for (const filePath of filesToDelete) {
+        try {
+          if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+            lines.push(`- Deleted: ${path.relative(repoRoot, filePath)}`);
+            deletedCount++;
+          } else {
+            lines.push(`- Skipped: ${path.relative(repoRoot, filePath)} (not found)`);
+          }
+        } catch (e) {
+          lines.push(`- Failed to delete ${path.relative(repoRoot, filePath)}: ${String(e)}`);
+        }
+      }
+
+      lines.push(``);
+      if (deletedCount > 0) {
+        lines.push(`✅ Reset complete - ${deletedCount} files deleted`);
+        lines.push(``);
+        lines.push(`Next steps:`);
+        lines.push(`1. Run: astro_init`);
+        lines.push(`2. Run: astro_status`);
+        lines.push(`3. Import your stories and restart workflow`);
+      } else {
+        lines.push(`ℹ️ No files found to delete`);
+      }
+
+      return lines.join("\n");
+    },
+  });
+}

package/src/tools/stage.ts

@@ -14,6 +14,7 @@ import { failRun, getActiveRun, getStageRuns, startStage, completeRun } from "..
 import { newEventId, newId } from "../state/ids";
 import { insertStory } from "../workflow/story-helpers";
 
+
 function nextStageKey(pipeline: StageKey[], current: StageKey): StageKey | null {
   const i = pipeline.indexOf(current);
   if (i === -1) return null;

package/src/tools/status.ts

@@ -3,6 +3,7 @@ import type { AstrocodeConfig } from "../config/schema";
 import type { SqliteDb } from "../state/db";
 import { decideNextAction, getActiveRun, getStageRuns, getStory } from "../workflow/state-machine";
 
+
 function statusIcon(status: string): string {
   switch (status) {
     case "running":
@@ -36,7 +37,7 @@ function stageIcon(status: string): string {
 }
 
 export function createAstroStatusTool(opts: { ctx: any; config: AstrocodeConfig; db?: SqliteDb | null }): ToolDefinition {
-  const { config, db } = opts;
+  const { ctx, config, db } = opts;
 
   return tool({
     description: "Show a compact Astrocode status dashboard: active run/stage, pipeline, story board counts, and next action.",

package/src/tools/story.ts

@@ -8,6 +8,7 @@ import type { StoryState } from "../state/types";
 import { insertStory } from "../workflow/story-helpers";
 
 
+
 export function createAstroStoryQueueTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
   const { db } = opts;