astrocode-workflow 0.4.1 → 0.4.3

package/dist/src/astro/workflow-runner.d.ts

@@ -1,14 +1,10 @@
 /**
- * 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 declare function runAstroWorkflow(opts: {
-    lockPath: string;
-    repoRoot: string;
-    sessionId: string;
-    owner?: string;
     proceedOneStep: () => Promise<{
         done: boolean;
     }>;

package/dist/src/astro/workflow-runner.js

@@ -1,25 +1,14 @@
 // 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) {
-    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/dist/src/hooks/inject-provider.js

@@ -1,6 +1,7 @@
 import { selectEligibleInjects } from "../tools/injects";
 import { injectChatPrompt } from "../ui/inject";
 import { nowISO } from "../shared/time";
+import { getActiveRun } from "../workflow/state-machine";
 export function createInjectProvider(opts) {
     const { ctx, config, runtime } = opts;
     const { db } = runtime;
@@ -184,6 +185,28 @@ export function createInjectProvider(opts) {
             await maybeAutoApprove(sessionId);
             // Inject eligible injects after workflow tool execution
             await injectEligibleInjects(sessionId, `tool_after:${input.tool}`);
+            // Inject Workflow Pulse if a run is active
+            await maybeInjectWorkflowPulse(sessionId);
         },
     };
+    async function maybeInjectWorkflowPulse(sessionId) {
+        if (!db)
+            return;
+        try {
+            const active = getActiveRun(db);
+            if (!active)
+                return;
+            const agentSuffix = active.current_stage_key ? ` (Agent: ${active.current_stage_key})` : "";
+            const pulseText = `📡 **ASTRO PULSE:** Run \`${active.run_id}\` is \`${active.status}\`${agentSuffix}.`;
+            await injectChatPrompt({
+                ctx,
+                sessionId,
+                text: pulseText,
+                agent: "Astro"
+            });
+        }
+        catch {
+            // Ignore pulse errors
+        }
+    }
 }

package/dist/src/index.js

@@ -37,12 +37,6 @@ const Astrocode = async (ctx) => {
         throw new Error("Astrocode requires ctx.directory to be a string repo root.");
     }
     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;
     try {

package/dist/src/tools/health.js

@@ -19,36 +19,6 @@ export function createAstroHealthTool(opts) {
             lines.push(`- PID: ${process.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.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`);
@@ -109,7 +79,6 @@ export function createAstroHealthTool(opts) {
             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/dist/src/tools/index.js

@@ -11,7 +11,6 @@ import { createAstroRepairTool } from "./repair";
 import { createAstroHealthTool } from "./health";
 import { createAstroResetTool } from "./reset";
 import { createAstroMetricsTool } from "./metrics";
-import { createAstroLockStatusTool } from "./lock";
 export function createAstroTools(opts) {
     const { ctx, config, agents, runtime } = opts;
     const { db } = runtime;
@@ -23,7 +22,6 @@ export function createAstroTools(opts) {
     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 });
     // Recovery tool - available even in limited mode to allow DB initialization
     tools.astro_init = createAstroInitTool({ ctx, config, runtime });
     // Database-dependent tools
@@ -85,7 +83,6 @@ export function createAstroTools(opts) {
         ["_astro_health", "astro_health"],
         ["_astro_reset", "astro_reset"],
         ["_astro_metrics", "astro_metrics"],
-        ["_astro_lock_status", "astro_lock_status"],
     ];
     // Only add aliases for tools that exist
     for (const [alias, target] of aliases) {

package/dist/src/tools/repair.js

@@ -1,53 +1,20 @@
-import path from "node:path";
 import { tool } from "@opencode-ai/plugin/tool";
 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) {
     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;
-            const lockPath = path.join(repoRoot, ".astro", "astro.lock");
-            // First, check and repair lock if requested
-            const lockLines = [];
-            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`;
                 const a = putArtifact({ repoRoot, db, run_id: null, stage_key: null, type: "log", rel_path: rel, content: fullMd, meta: { kind: "repair" } });