astrocode-workflow 0.3.5 → 0.4.1

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";
@@ -5,28 +6,64 @@ import { withTx } from "../state/db";
 import { repairState, formatRepairReport } from "../workflow/repair";
 import { putArtifact } from "../workflow/artifacts";
 import { nowISO } from "../shared/time";
+import { getLockStatus, tryRemoveStaleLock } from "../state/repo-lock";
 
 
 export function createAstroRepairTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
   const { ctx, config, db } = opts;
 
   return tool({
-    description: "Repair Astrocode invariants and recover from inconsistent DB state. Writes a repair report artifact.",
+    description: "Repair Astrocode invariants and recover from inconsistent DB state. Also checks and repairs lock files. Writes a repair report artifact.",
     args: {
       write_report_artifact: tool.schema.boolean().default(true),
+      repair_lock: tool.schema.boolean().default(true).describe("Attempt to remove stale/dead lock files"),
     },
-    execute: async ({ write_report_artifact }) => {
+    execute: async ({ write_report_artifact, repair_lock }) => {
       const repoRoot = ctx.directory as string;
+      const lockPath = path.join(repoRoot, ".astro", "astro.lock");
+
+      // First, check and repair lock if requested
+      const lockLines: string[] = [];
+      const lockStatus = getLockStatus(lockPath);
+
+      if (lockStatus.exists) {
+        lockLines.push("## Lock Status");
+        lockLines.push(`- Lock found: ${lockPath}`);
+        lockLines.push(`- PID: ${lockStatus.pid} (${lockStatus.pidAlive ? 'alive' : 'dead'})`);
+        lockLines.push(`- Age: ${lockStatus.ageMs ? Math.floor(lockStatus.ageMs / 1000) : '?'}s`);
+        lockLines.push(`- Status: ${lockStatus.isStale ? 'stale' : 'fresh'}`);
+
+        if (repair_lock) {
+          const result = tryRemoveStaleLock(lockPath);
+          if (result.removed) {
+            lockLines.push(`- **Removed**: ${result.reason}`);
+          } else {
+            lockLines.push(`- **Not removed**: ${result.reason}`);
+          }
+        } else {
+          if (!lockStatus.pidAlive || lockStatus.isStale) {
+            lockLines.push(`- **Recommendation**: Run with repair_lock=true to remove this ${!lockStatus.pidAlive ? 'dead' : 'stale'} lock`);
+          }
+        }
+        lockLines.push("");
+      }
+
+      // Then repair database state
       const report = withTx(db, () => repairState(db, config));
-      const md = formatRepairReport(report);
+      const dbMd = formatRepairReport(report);
+
+      // Combine lock and DB repair
+      const fullMd = lockLines.length > 0
+        ? `# Astrocode Repair Report\n\n${lockLines.join("\n")}\n${dbMd.replace(/^# Astrocode repair report\n*/i, "")}`
+        : dbMd;
 
       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/workflow.ts

@@ -199,6 +199,7 @@ export function createAstroWorkflowProceedTool(opts: { ctx: any; config: Astroco
           repoRoot,
           sessionId,
           owner: "astro_workflow_proceed",
+          advisory: true, // Advisory mode: warn instead of blocking on lock contention
           fn: async () => {
         const steps = Math.min(max_steps, config.workflow.loop_max_steps_hard_cap);
 

package/src/workflow/repair.ts

@@ -72,11 +72,11 @@ export function repairState(db: SqliteDb, config: AstrocodeConfig): RepairReport
     if (stageRuns.length < pipeline.length) {
       const existingKeys = new Set(stageRuns.map((s) => s.stage_key));
       const insert = db.prepare(
-        "INSERT INTO stage_runs (stage_run_id, run_id, stage_key, stage_index, status, updated_at) VALUES (?, ?, ?, ?, 'pending', ?)"
+        "INSERT INTO stage_runs (stage_run_id, run_id, stage_key, stage_index, status, created_at, updated_at) VALUES (?, ?, ?, ?, 'pending', ?, ?)"
       );
       pipeline.forEach((key, idx) => {
         if (!existingKeys.has(key as any)) {
-          insert.run(newStageRunId(), active.run_id, key, idx, now);
+          insert.run(newStageRunId(), active.run_id, key, idx, now, now);
           push(report, `Inserted missing stage_run ${key} for run ${active.run_id}`);
         }
       });