astrocode-workflow 0.4.1 → 0.4.2

package/src/astro/workflow-runner.ts

@@ -1,36 +1,16 @@
 // src/astro/workflow-runner.ts
-import { acquireRepoLock } from "../state/repo-lock";
-import { workflowRepoLock } from "../state/workflow-repo-lock";
 
 /**
- * This is the only place you should hold the repo lock.
+ * Executes the workflow loop.
  * Everything that mutates the repo (tool calls, steps) runs inside this scope.
  *
  * Replace the internals with your actual astro/opencode driver loop.
  */
 export async function runAstroWorkflow(opts: {
-  lockPath: string;
-  repoRoot: string;
-  sessionId: string;
-  owner?: string;
-
-  // Hook in your existing workflow engine
   proceedOneStep: () => Promise<{ done: boolean }>;
 }): Promise<void> {
-  await workflowRepoLock(
-    { acquireRepoLock },
-    {
-      lockPath: opts.lockPath,
-      repoRoot: opts.repoRoot,
-      sessionId: opts.sessionId,
-      owner: opts.owner,
-      fn: async () => {
-        // ✅ Lock is held ONCE for the entire run. Tool calls can "rattle through".
-        while (true) {
-          const { done } = await opts.proceedOneStep();
-          if (done) return;
-        }
-      },
-    }
-  );
+  while (true) {
+    const { done } = await opts.proceedOneStep();
+    if (done) return;
+  }
 }

package/src/index.ts

@@ -59,13 +59,6 @@ const Astrocode: Plugin = async (ctx) => {
   }
   const repoRoot = ctx.directory;
 
-  // NOTE: Repo locking is handled at the workflow level via workflowRepoLock.
-  // The workflow tool correctly acquires and holds the lock for the entire workflow execution.
-  // Plugin-level locking is unnecessary and architecturally incorrect since:
-  // - The lock would be held for the entire session lifecycle (too long)
-  // - Individual tools are designed to be called within workflow context where lock is held
-  // - Workflow-level locking with refcounting prevents lock churn during tool execution
-
   // Always load config first - this provides defaults even in limited mode
   let pluginConfig: AstrocodeConfig;
   try {

package/src/tools/health.ts

@@ -25,34 +25,6 @@ export function createAstroHealthTool(opts: { ctx: any; config: AstrocodeConfig;
       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`);
@@ -116,7 +88,6 @@ export function createAstroHealthTool(opts: { ctx: any; config: AstrocodeConfig;
       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`);

package/src/tools/index.ts

@@ -15,7 +15,6 @@ import { createAstroRepairTool } from "./repair";
 import { createAstroHealthTool } from "./health";
 import { createAstroResetTool } from "./reset";
 import { createAstroMetricsTool } from "./metrics";
-import { createAstroLockStatusTool } from "./lock";
 
 import { AgentConfig } from "@opencode-ai/sdk";
 
@@ -44,8 +43,7 @@ export function createAstroTools(opts: CreateAstroToolsOptions): Record<string,
      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 });
-     tools.astro_lock_status = createAstroLockStatusTool({ ctx });
+      tools.astro_metrics = createAstroMetricsTool({ ctx, config });
 
    // Recovery tool - available even in limited mode to allow DB initialization
    tools.astro_init = createAstroInitTool({ ctx, config, runtime });
@@ -110,8 +108,7 @@ export function createAstroTools(opts: CreateAstroToolsOptions): Record<string,
     ["_astro_repair", "astro_repair"],
      ["_astro_health", "astro_health"],
      ["_astro_reset", "astro_reset"],
-     ["_astro_metrics", "astro_metrics"],
-     ["_astro_lock_status", "astro_lock_status"],
+      ["_astro_metrics", "astro_metrics"],
   ];
 
   // Only add aliases for tools that exist

package/src/tools/repair.ts

@@ -6,56 +6,22 @@ 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. Also checks and repairs lock files. Writes a repair report artifact.",
+    description: "Repair Astrocode invariants and recover from inconsistent DB state. 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, repair_lock }) => {
+    execute: async ({ write_report_artifact }) => {
       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
+      // Repair database state
       const report = withTx(db, () => repairState(db, config));
-      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;
+      const fullMd = formatRepairReport(report);
 
       if (write_report_artifact) {
         const rel = `.astro/repair/repair_${nowISO().replace(/[:.]/g, "-")}.md`;

package/src/tools/workflow.ts

@@ -24,8 +24,6 @@ import { newEventId } from "../state/ids";
 import { debug } from "../shared/log";
 import { createToastManager } from "../ui/toasts";
 import type { AgentConfig } from "@opencode-ai/sdk";
-import { acquireRepoLock } from "../state/repo-lock";
-import { workflowRepoLock } from "../state/workflow-repo-lock";
 
 // Agent name mapping for case-sensitive resolution
 export const STAGE_TO_AGENT_MAP: Record<string, string> = {
@@ -188,20 +186,8 @@ export function createAstroWorkflowProceedTool(opts: { ctx: any; config: Astroco
       max_steps: tool.schema.number().int().positive().default(config.workflow.default_max_steps),
     },
     execute: async ({ mode, max_steps }) => {
-      const repoRoot = (ctx as any).directory as string;
-      const lockPath = path.join(repoRoot, ".astro", "astro.lock");
       const sessionId = (ctx as any).sessionID as string | undefined;
-
-      return workflowRepoLock(
-        { acquireRepoLock },
-        {
-          lockPath,
-          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);
+      const steps = Math.min(max_steps, config.workflow.loop_max_steps_hard_cap);
 
       const actions: string[] = [];
       const warnings: string[] = [];
@@ -424,8 +410,6 @@ export function createAstroWorkflowProceedTool(opts: { ctx: any; config: Astroco
       }
 
       return lines.join("\n").trim();
-          },
-        });
     },
   });
 }