astrocode-workflow 0.3.1 → 0.3.2

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/repo-lock.ts

@@ -0,0 +1,158 @@
+// src/state/repo-lock.ts
+import fs from "node:fs";
+import path from "node:path";
+
+type LockFile = {
+  pid: number;
+  created_at: string;
+  updated_at: string;
+  repo_root: string;
+  session_id?: string;
+  owner?: string; // optional human-readable owner
+};
+
+function nowISO(): string {
+  return new Date().toISOString();
+}
+
+function sleep(ms: number) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+function isPidAlive(pid: number): boolean {
+  try {
+    // Signal 0 checks existence without killing.
+    (process as any).kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function readLock(lockPath: string): LockFile | null {
+  try {
+    const raw = fs.readFileSync(lockPath, "utf8");
+    const parsed = JSON.parse(raw) as LockFile;
+    if (!parsed || typeof parsed.pid !== "number") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function writeLock(lockPath: string, lock: LockFile) {
+  fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+  fs.writeFileSync(lockPath, JSON.stringify(lock, null, 2));
+}
+
+function safeUnlink(lockPath: string) {
+  try {
+    fs.unlinkSync(lockPath);
+  } catch {
+    // ignore
+  }
+}
+
+/**
+ * Acquire a repo-scoped lock with:
+ * - Re-entrant behavior for SAME PID (your own process can call tools repeatedly)
+ * - Stale lock eviction for dead PIDs
+ * - Best-effort contention retry
+ */
+export async function acquireRepoLock(opts: {
+  lockPath: string;
+  repoRoot: string;
+  sessionId?: string;
+  owner?: string;
+  retryMs?: number;      // default 2000
+  pollMs?: number;       // default 100
+}): Promise<{ release: () => void }> {
+  const { lockPath, repoRoot, sessionId, owner } = opts;
+  const retryMs = opts.retryMs ?? 2000;
+  const pollMs = opts.pollMs ?? 100;
+
+  const myPid = (process as any).pid;
+  const startedAt = Date.now();
+
+  while (true) {
+    const existing = readLock(lockPath);
+
+    // No lock -> take it.
+    if (!existing) {
+      const now = nowISO();
+      writeLock(lockPath, {
+        pid: myPid,
+        created_at: now,
+        updated_at: now,
+        repo_root: repoRoot,
+        session_id: sessionId,
+        owner,
+      });
+
+      // Verify we actually own it (race safety)
+      const verify = readLock(lockPath);
+      if (verify && verify.pid === myPid) {
+        return {
+          release: () => {
+            const cur = readLock(lockPath);
+            // Only the owner PID removes the lock.
+            if (cur && cur.pid === myPid) safeUnlink(lockPath);
+          },
+        };
+      }
+
+      // Race lost; retry.
+    } else {
+      // Re-entrant: SAME PID owns lock -> refresh timestamp and proceed.
+      if (existing.pid === myPid) {
+        const now = nowISO();
+        writeLock(lockPath, { ...existing, updated_at: now, session_id: sessionId ?? existing.session_id, owner: owner ?? existing.owner });
+        return {
+          release: () => {
+            const cur = readLock(lockPath);
+            if (cur && cur.pid === myPid) safeUnlink(lockPath);
+          },
+        };
+      }
+
+      // Another PID: if dead -> evict stale lock
+      if (!isPidAlive(existing.pid)) {
+        safeUnlink(lockPath);
+        // loop back and acquire
+      } else {
+        // Alive and not us -> wait bounded
+        if (Date.now() - startedAt > retryMs) {
+          throw new Error(
+            `Astrocode lock is already held (${lockPath}). pid=${existing.pid} (alive). ` +
+            `Close other opencode processes or wait.`
+          );
+        }
+        await sleep(pollMs);
+      }
+    }
+  }
+}
+
+/**
+ * Helper wrapper: always releases lock.
+ */
+export async function withRepoLock<T>(opts: {
+  lockPath: string;
+  repoRoot: string;
+  sessionId?: string;
+  owner?: string;
+  fn: () => Promise<T>;
+}): Promise<T> {
+  const handle = await acquireRepoLock({
+    lockPath: opts.lockPath,
+    repoRoot: opts.repoRoot,
+    sessionId: opts.sessionId,
+    owner: opts.owner,
+  });
+
+  try {
+    return await opts.fn();
+  } finally {
+    handle.release();
+  }
+}

package/src/tools/health.ts

@@ -0,0 +1,128 @@
+// 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}`);
+
+      // Lock status
+      const lockPath = `${repoRoot}/.astro/astro.lock`;
+      try {
+        if (fs.existsSync(lockPath)) {
+          const lockContent = fs.readFileSync(lockPath, "utf8").trim();
+          const parts = lockContent.split(" ");
+          if (parts.length >= 2) {
+            const pid = parseInt(parts[0]);
+            const startedAt = parts[1];
+
+            // Check if PID is still running
+            try {
+              (process as any).kill(pid, 0); // Signal 0 just checks if process exists
+              lines.push(`- Lock: HELD by PID ${pid} (started ${startedAt})`);
+            } catch {
+              lines.push(`- Lock: STALE (PID ${pid} not running, started ${startedAt})`);
+              lines.push(`  → Run: rm "${lockPath}"`);
+            }
+          } else {
+            lines.push(`- Lock: MALFORMED (${lockContent})`);
+          }
+        } else {
+          lines.push(`- Lock: NONE (no lock file)`);
+        }
+      } catch (e) {
+        lines.push(`- Lock: ERROR (${String(e)})`);
+      }
+
+      // 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`);
+      lines.push(`✅ Lock file checked`);
+
+      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

@@ -7,6 +7,7 @@ import { ensureSchema, openSqlite, configurePragmas } from "../state/db";
 import { getAstroPaths, ensureAstroDirs } from "../shared/paths";
 import { nowISO } from "../shared/time";
 import { sha256Hex } from "../shared/hash";
+import { withRepoLock } from "../state/repo-lock";
 
 type RuntimeState = {
   db: SqliteDb | null;
@@ -29,14 +30,23 @@ 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 lockPath = path.join(repoRoot, ".astro", "astro.lock");
+      const sessionId = (ctx as any).sessionID as string | undefined;
 
-      const hadDbAlready = !!runtime.db;
-      let db: SqliteDb | null = runtime.db;
-      let publishedToRuntime = false;
+      return withRepoLock({
+        lockPath,
+        repoRoot,
+        sessionId,
+        owner: "astro_init",
+        fn: async () => {
+          const paths = getAstroPaths(repoRoot, config.db.path);
+          ensureAstroDirs(paths);
 
-      try {
+          const hadDbAlready = !!runtime.db;
+          let db: SqliteDb | null = runtime.db;
+          let publishedToRuntime = false;
+
+          try {
         if (!db) {
           try {
             db = openSqlite(paths.dbPath, { busyTimeoutMs: config.db.busy_timeout_ms });
@@ -106,14 +116,16 @@ export function createAstroInitTool(opts: { ctx: any; config: AstrocodeConfig; r
             ? `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 {}
-        }
-      }
+          } 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 {}
+            }
+          }
+        },
+      });
     },
   });
 }

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,10 +1,12 @@
 import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
+import path from "node:path";
 import type { AstrocodeConfig } from "../config/schema";
 import type { SqliteDb } from "../state/db";
 import { withTx } from "../state/db";
 import { repairState, formatRepairReport } from "../workflow/repair";
 import { putArtifact } from "../workflow/artifacts";
 import { nowISO } from "../shared/time";
+import { withRepoLock } from "../state/repo-lock";
 
 export function createAstroRepairTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
   const { ctx, config, db } = opts;
@@ -16,16 +18,27 @@ export function createAstroRepairTool(opts: { ctx: any; config: AstrocodeConfig;
     },
     execute: async ({ write_report_artifact }) => {
       const repoRoot = ctx.directory as string;
-      const report = withTx(db, () => repairState(db, config));
-      const md = formatRepairReport(report);
+      const lockPath = path.join(repoRoot, ".astro", "astro.lock");
+      const sessionId = (ctx as any).sessionID as string | undefined;
 
-      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})`;
-      }
+      return withRepoLock({
+        lockPath,
+        repoRoot,
+        sessionId,
+        owner: "astro_repair",
+        fn: async () => {
+          const report = withTx(db, () => repairState(db, config));
+          const md = formatRepairReport(report);
 
-      return md;
+          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})`;
+          }
+
+          return md;
+        },
+      });
     },
   });
 }

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");
+    },
+  });
+}