astrocode-workflow 0.4.1 → 0.4.3

package/dist/src/tools/workflow.js

@@ -1,6 +1,5 @@
 // src/tools/workflow.ts
 import { tool } from "@opencode-ai/plugin/tool";
-import path from "node:path";
 import { withTx } from "../state/db";
 import { buildContextSnapshot } from "../workflow/context";
 import { decideNextAction, createRunForStory, startStage, completeRun, failRun, getActiveRun, EVENT_TYPES, } from "../workflow/state-machine";
@@ -10,8 +9,6 @@ import { nowISO } from "../shared/time";
 import { newEventId } from "../state/ids";
 import { debug } from "../shared/log";
 import { createToastManager } from "../ui/toasts";
-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 = {
     frame: "Frame",
@@ -113,36 +110,33 @@ function buildUiMessage(e) {
         case "stage_started": {
             const agent = e.agent_name ? ` (${e.agent_name})` : "";
             const title = "Astrocode";
-            const message = `Stage started: ${e.stage_key}${agent}`;
+            const message = `▶ Stage started: ${e.stage_key}${agent}`;
             const chatText = [
-                `[SYSTEM DIRECTIVE: ASTROCODE — STAGE_STARTED]`,
-                ``,
-                `Run: ${e.run_id}`,
-                `Stage: ${e.stage_key}${agent}`,
+                `### ▶ ASTROCODE: STAGE_STARTED`,
+                `**Run:** \`${e.run_id}\`  `,
+                `**Stage:** \`${e.stage_key}\`${agent}`,
             ].join("\n");
             return { title, message, variant: "info", chatText };
         }
         case "run_completed": {
             const title = "Astrocode";
-            const message = `Run completed: ${e.run_id}`;
+            const message = `✓ Run completed: ${e.run_id}`;
             const chatText = [
-                `[SYSTEM DIRECTIVE: ASTROCODE — RUN_COMPLETED]`,
-                ``,
-                `Run: ${e.run_id}`,
-                `Story: ${e.story_key}`,
+                `### ✓ ASTROCODE: RUN_COMPLETED`,
+                `**Run:** \`${e.run_id}\`  `,
+                `**Story:** \`${e.story_key}\``,
             ].join("\n");
             return { title, message, variant: "success", chatText };
         }
         case "run_failed": {
             const title = "Astrocode";
-            const message = `Run failed: ${e.run_id} (${e.stage_key})`;
+            const message = `✖ Run failed: ${e.run_id} (${e.stage_key})`;
             const chatText = [
-                `[SYSTEM DIRECTIVE: ASTROCODE — RUN_FAILED]`,
-                ``,
-                `Run: ${e.run_id}`,
-                `Story: ${e.story_key}`,
-                `Stage: ${e.stage_key}`,
-                `Error: ${e.error_text}`,
+                `### ✖ ASTROCODE: RUN_FAILED`,
+                `**Run:** \`${e.run_id}\`  `,
+                `**Story:** \`${e.story_key}\`  `,
+                `**Stage:** \`${e.stage_key}\`  `,
+                `**Error:** ${e.error_text}`,
             ].join("\n");
             return { title, message, variant: "error", chatText };
         }
@@ -158,202 +152,191 @@ export function createAstroWorkflowProceedTool(opts) {
             max_steps: tool.schema.number().int().positive().default(config.workflow.default_max_steps),
         },
         execute: async ({ mode, max_steps }) => {
-            const repoRoot = ctx.directory;
-            const lockPath = path.join(repoRoot, ".astro", "astro.lock");
             const sessionId = ctx.sessionID;
-            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 actions = [];
-                    const warnings = [];
-                    const startedAt = nowISO();
-                    // Collect UI events emitted inside state-machine functions, then flush AFTER tx.
-                    const uiEvents = [];
-                    const emit = (e) => uiEvents.push(e);
-                    for (let i = 0; i < steps; i++) {
-                        const next = decideNextAction(db, config);
-                        if (next.kind === "idle") {
-                            actions.push("idle: no approved stories");
-                            break;
-                        }
-                        if (next.kind === "start_run") {
-                            // SINGLE tx boundary: caller owns tx, state-machine is pure.
-                            const { run_id } = withTx(db, () => createRunForStory(db, config, next.story_key));
-                            actions.push(`started run ${run_id} for story ${next.story_key}`);
-                            if (mode === "step")
-                                break;
-                            continue;
-                        }
-                        if (next.kind === "complete_run") {
-                            withTx(db, () => completeRun(db, next.run_id, emit));
-                            actions.push(`completed run ${next.run_id}`);
-                            if (mode === "step")
-                                break;
-                            continue;
-                        }
-                        if (next.kind === "failed") {
-                            // Ensure DB state reflects failure in one tx; emit UI event.
-                            withTx(db, () => failRun(db, next.run_id, next.stage_key, next.error_text, emit));
-                            actions.push(`failed: ${next.stage_key} — ${next.error_text}`);
-                            if (mode === "step")
-                                break;
-                            continue;
-                        }
-                        if (next.kind === "delegate_stage") {
-                            const active = getActiveRun(db);
-                            if (!active)
-                                throw new Error("Invariant: delegate_stage but no active run.");
-                            const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(active.run_id);
-                            const story = db.prepare("SELECT * FROM stories WHERE story_key=?").get(run.story_key);
-                            let agentName = resolveAgentName(next.stage_key, config, agents, warnings);
-                            const agentExists = (name) => {
-                                if (agents && agents[name])
-                                    return true;
-                                const knownStageAgents = ["Frame", "Plan", "Spec", "Implement", "Review", "Verify", "Close", "General", "Astro", "general"];
-                                if (knownStageAgents.includes(name))
-                                    return true;
-                                return false;
-                            };
+            const steps = Math.min(max_steps, config.workflow.loop_max_steps_hard_cap);
+            const actions = [];
+            const warnings = [];
+            const startedAt = nowISO();
+            // Collect UI events emitted inside state-machine functions, then flush AFTER tx.
+            const uiEvents = [];
+            const emit = (e) => uiEvents.push(e);
+            for (let i = 0; i < steps; i++) {
+                const next = decideNextAction(db, config);
+                if (next.kind === "idle") {
+                    actions.push("idle: no approved stories");
+                    break;
+                }
+                if (next.kind === "start_run") {
+                    // SINGLE tx boundary: caller owns tx, state-machine is pure.
+                    const { run_id } = withTx(db, () => createRunForStory(db, config, next.story_key));
+                    actions.push(`started run ${run_id} for story ${next.story_key}`);
+                    if (mode === "step")
+                        break;
+                    continue;
+                }
+                if (next.kind === "complete_run") {
+                    withTx(db, () => completeRun(db, next.run_id, emit));
+                    actions.push(`completed run ${next.run_id}`);
+                    if (mode === "step")
+                        break;
+                    continue;
+                }
+                if (next.kind === "failed") {
+                    // Ensure DB state reflects failure in one tx; emit UI event.
+                    withTx(db, () => failRun(db, next.run_id, next.stage_key, next.error_text, emit));
+                    actions.push(`failed: ${next.stage_key} — ${next.error_text}`);
+                    if (mode === "step")
+                        break;
+                    continue;
+                }
+                if (next.kind === "delegate_stage") {
+                    const active = getActiveRun(db);
+                    if (!active)
+                        throw new Error("Invariant: delegate_stage but no active run.");
+                    const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(active.run_id);
+                    const story = db.prepare("SELECT * FROM stories WHERE story_key=?").get(run.story_key);
+                    let agentName = resolveAgentName(next.stage_key, config, agents, warnings);
+                    const agentExists = (name) => {
+                        if (agents && agents[name])
+                            return true;
+                        const knownStageAgents = ["Frame", "Plan", "Spec", "Implement", "Review", "Verify", "Close", "General", "Astro", "general"];
+                        if (knownStageAgents.includes(name))
+                            return true;
+                        return false;
+                    };
+                    if (!agentExists(agentName)) {
+                        const originalAgent = agentName;
+                        console.warn(`[Astrocode] Agent ${agentName} not found. Falling back to orchestrator.`);
+                        agentName = config.agents?.orchestrator_name || "Astro";
+                        if (!agentExists(agentName)) {
+                            console.warn(`[Astrocode] Orchestrator ${agentName} not available. Falling back to General.`);
+                            agentName = "General";
                             if (!agentExists(agentName)) {
-                                const originalAgent = agentName;
-                                console.warn(`[Astrocode] Agent ${agentName} not found. Falling back to orchestrator.`);
-                                agentName = config.agents?.orchestrator_name || "Astro";
-                                if (!agentExists(agentName)) {
-                                    console.warn(`[Astrocode] Orchestrator ${agentName} not available. Falling back to General.`);
-                                    agentName = "General";
-                                    if (!agentExists(agentName)) {
-                                        throw new Error(`Critical: No agents available for delegation. Primary: ${originalAgent}, Orchestrator: ${config.agents?.orchestrator_name || "Astro"}, General: unavailable`);
-                                    }
-                                }
-                            }
-                            // NOTE: startStage owns its own tx (state-machine.ts).
-                            withTx(db, () => {
-                                startStage(db, active.run_id, next.stage_key, { subagent_type: agentName }, emit);
-                            });
-                            const context = buildContextSnapshot({
-                                db,
-                                config,
-                                run_id: active.run_id,
-                                next_action: `delegate stage ${next.stage_key}`,
-                            });
-                            const stageDirective = buildStageDirective({
-                                config,
-                                stage_key: next.stage_key,
-                                run_id: active.run_id,
-                                story_key: run.story_key,
-                                story_title: story?.title ?? "(missing)",
-                                stage_agent_name: agentName,
-                                stage_goal: stageGoal(next.stage_key, config),
-                                stage_constraints: stageConstraints(next.stage_key, config),
-                                context_snapshot_md: context,
-                            }).body;
-                            const delegatePrompt = buildDelegationPrompt({
-                                stageDirective,
-                                run_id: active.run_id,
-                                stage_key: next.stage_key,
-                                stage_agent_name: agentName,
-                            });
-                            // Record continuation (best-effort; no tx wrapper needed but safe either way)
-                            const h = directiveHash(delegatePrompt);
-                            const now = nowISO();
-                            if (sessionId) {
-                                // This assumes continuations table exists in vNext schema.
-                                db.prepare("INSERT INTO continuations (session_id, run_id, directive_hash, kind, reason, created_at) VALUES (?, ?, ?, 'stage', ?, ?)").run(sessionId, active.run_id, h, `delegate ${next.stage_key}`, now);
-                            }
-                            // Visible injection so user can see state (awaited)
-                            if (sessionId) {
-                                await injectChatPrompt({ ctx, sessionId, text: delegatePrompt, agent: "Astro" });
-                                const continueMessage = [
-                                    `[SYSTEM DIRECTIVE: ASTROCODE — AWAIT_STAGE_COMPLETION]`,
-                                    ``,
-                                    `Stage \`${next.stage_key}\` delegated to \`${agentName}\`.`,
-                                    ``,
-                                    `When \`${agentName}\` completes, call:`,
-                                    `astro_stage_complete(run_id="${active.run_id}", stage_key="${next.stage_key}", output_text="[paste subagent output here]")`,
-                                    ``,
-                                    `This advances the workflow.`,
-                                ].join("\n");
-                                await injectChatPrompt({ ctx, sessionId, text: continueMessage, agent: "Astro" });
+                                throw new Error(`Critical: No agents available for delegation. Primary: ${originalAgent}, Orchestrator: ${config.agents?.orchestrator_name || "Astro"}, General: unavailable`);
                             }
-                            actions.push(`delegated stage ${next.stage_key} via ${agentName}`);
-                            // Stop here; subagent needs to run.
-                            break;
                         }
-                        if (next.kind === "await_stage_completion") {
-                            actions.push(`await stage completion: ${next.stage_key}`);
-                            if (sessionId) {
-                                const context = buildContextSnapshot({
-                                    db,
-                                    config,
-                                    run_id: next.run_id,
-                                    next_action: `complete stage ${next.stage_key}`,
-                                });
-                                const prompt = [
-                                    `[SYSTEM DIRECTIVE: ASTROCODE — AWAIT_STAGE_OUTPUT]`,
-                                    ``,
-                                    `Run \`${next.run_id}\` is waiting for stage \`${next.stage_key}\` output.`,
-                                    `If you have the subagent output, call astro_stage_complete with output_text=the FULL output.`,
-                                    ``,
-                                    `Context snapshot:`,
-                                    context,
-                                ].join("\n").trim();
-                                const h = directiveHash(prompt);
-                                const now = nowISO();
-                                db.prepare("INSERT INTO continuations (session_id, run_id, directive_hash, kind, reason, created_at) VALUES (?, ?, ?, 'continue', ?, ?)").run(sessionId, next.run_id, h, `await ${next.stage_key}`, now);
-                                await injectChatPrompt({ ctx, sessionId, text: prompt, agent: "Astro" });
-                            }
-                            break;
-                        }
-                        actions.push(`unhandled next action: ${next.kind}`);
-                        break;
                     }
-                    // Flush UI events (toast + prompt) AFTER state transitions
-                    if (uiEvents.length > 0) {
-                        for (const e of uiEvents) {
-                            const msg = buildUiMessage(e);
-                            if (config.ui.toasts.enabled) {
-                                await toasts.show({
-                                    title: msg.title,
-                                    message: msg.message,
-                                    variant: msg.variant,
-                                });
-                            }
-                            if (ctx?.sessionID) {
-                                await injectChatPrompt({
-                                    ctx,
-                                    sessionId: ctx.sessionID,
-                                    text: msg.chatText,
-                                    agent: "Astro",
-                                });
-                            }
-                        }
-                        actions.push(`ui: flushed ${uiEvents.length} event(s)`);
+                    // NOTE: startStage owns its own tx (state-machine.ts).
+                    withTx(db, () => {
+                        startStage(db, active.run_id, next.stage_key, { subagent_type: agentName }, emit);
+                    });
+                    const context = buildContextSnapshot({
+                        db,
+                        config,
+                        run_id: active.run_id,
+                        next_action: `delegate stage ${next.stage_key}`,
+                    });
+                    const stageDirective = buildStageDirective({
+                        config,
+                        stage_key: next.stage_key,
+                        run_id: active.run_id,
+                        story_key: run.story_key,
+                        story_title: story?.title ?? "(missing)",
+                        stage_agent_name: agentName,
+                        stage_goal: stageGoal(next.stage_key, config),
+                        stage_constraints: stageConstraints(next.stage_key, config),
+                        context_snapshot_md: context,
+                    }).body;
+                    const delegatePrompt = buildDelegationPrompt({
+                        stageDirective,
+                        run_id: active.run_id,
+                        stage_key: next.stage_key,
+                        stage_agent_name: agentName,
+                    });
+                    // Record continuation (best-effort; no tx wrapper needed but safe either way)
+                    const h = directiveHash(delegatePrompt);
+                    const now = nowISO();
+                    if (sessionId) {
+                        // This assumes continuations table exists in vNext schema.
+                        db.prepare("INSERT INTO continuations (session_id, run_id, directive_hash, kind, reason, created_at) VALUES (?, ?, ?, 'stage', ?, ?)").run(sessionId, active.run_id, h, `delegate ${next.stage_key}`, now);
                     }
-                    // Housekeeping event
-                    db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, NULL, NULL, ?, ?, ?)").run(newEventId(), EVENT_TYPES.WORKFLOW_PROCEED, JSON.stringify({ started_at: startedAt, mode, max_steps: steps, actions }), nowISO());
-                    const active = getActiveRun(db);
-                    const lines = [];
-                    lines.push(`# astro_workflow_proceed`);
-                    lines.push(`- mode: ${mode}`);
-                    lines.push(`- steps requested: ${max_steps} (cap=${steps})`);
-                    if (active)
-                        lines.push(`- active run: \`${active.run_id}\` (stage=${active.current_stage_key ?? "?"})`);
-                    lines.push(``, `## Actions`);
-                    for (const a of actions)
-                        lines.push(`- ${a}`);
-                    if (warnings.length > 0) {
-                        lines.push(``, `## Warnings`);
-                        for (const w of warnings)
-                            lines.push(`⚠️ ${w}`);
+                    // Visible injection so user can see state (awaited)
+                    if (sessionId) {
+                        await injectChatPrompt({ ctx, sessionId, text: delegatePrompt, agent: "Astro" });
+                        const continueMessage = [
+                            `### ⏳ ASTROCODE: AWAITING COMPLETION`,
+                            `Stage \`${next.stage_key}\` delegated to \`${agentName}\`.`,
+                            ``,
+                            `**Action Required:** When \`${agentName}\` completes, call:`,
+                            `\`\`\`bash`,
+                            `astro_stage_complete(run_id="${active.run_id}", stage_key="${next.stage_key}", output_text="...")`,
+                            `\`\`\``,
+                            `*Then run \`astro_workflow_proceed\` to continue.*`,
+                        ].join("\n");
+                        await injectChatPrompt({ ctx, sessionId, text: continueMessage, agent: "Astro" });
+                    }
+                    actions.push(`delegated stage ${next.stage_key} via ${agentName}`);
+                    // Stop here; subagent needs to run.
+                    break;
+                }
+                if (next.kind === "await_stage_completion") {
+                    actions.push(`await stage completion: ${next.stage_key}`);
+                    if (sessionId) {
+                        const context = buildContextSnapshot({
+                            db,
+                            config,
+                            run_id: next.run_id,
+                            next_action: `complete stage ${next.stage_key}`,
+                        });
+                        const prompt = [
+                            `### 📥 ASTROCODE: AWAITING OUTPUT`,
+                            `Run \`${next.run_id}\` is waiting for stage \`${next.stage_key}\` output.`,
+                            ``,
+                            `**Action Required:** If you have the subagent output, call \`astro_stage_complete\` with \`output_text=the FULL output\`.`,
+                            ``,
+                            `#### Context Snapshot`,
+                            context,
+                        ].join("\n").trim();
+                        const h = directiveHash(prompt);
+                        const now = nowISO();
+                        db.prepare("INSERT INTO continuations (session_id, run_id, directive_hash, kind, reason, created_at) VALUES (?, ?, ?, 'continue', ?, ?)").run(sessionId, next.run_id, h, `await ${next.stage_key}`, now);
+                        await injectChatPrompt({ ctx, sessionId, text: prompt, agent: "Astro" });
+                    }
+                    break;
+                }
+                actions.push(`unhandled next action: ${next.kind}`);
+                break;
+            }
+            // Flush UI events (toast + prompt) AFTER state transitions
+            if (uiEvents.length > 0) {
+                for (const e of uiEvents) {
+                    const msg = buildUiMessage(e);
+                    if (config.ui.toasts.enabled) {
+                        await toasts.show({
+                            title: msg.title,
+                            message: msg.message,
+                            variant: msg.variant,
+                        });
+                    }
+                    if (ctx?.sessionID) {
+                        await injectChatPrompt({
+                            ctx,
+                            sessionId: ctx.sessionID,
+                            text: msg.chatText,
+                            agent: "Astro",
+                        });
                     }
-                    return lines.join("\n").trim();
-                },
-            });
+                }
+                actions.push(`ui: flushed ${uiEvents.length} event(s)`);
+            }
+            // Housekeeping event
+            db.prepare("INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, NULL, NULL, ?, ?, ?)").run(newEventId(), EVENT_TYPES.WORKFLOW_PROCEED, JSON.stringify({ started_at: startedAt, mode, max_steps: steps, actions }), nowISO());
+            const active = getActiveRun(db);
+            const lines = [];
+            lines.push(`# astro_workflow_proceed`);
+            lines.push(`- mode: ${mode}`);
+            lines.push(`- steps requested: ${max_steps} (cap=${steps})`);
+            if (active)
+                lines.push(`- active run: \`${active.run_id}\` (stage=${active.current_stage_key ?? "?"})`);
+            lines.push(``, `## Actions`);
+            for (const a of actions)
+                lines.push(`- ${a}`);
+            if (warnings.length > 0) {
+                lines.push(``, `## Warnings`);
+                for (const w of warnings)
+                    lines.push(`⚠️ ${w}`);
+            }
+            return lines.join("\n").trim();
         },
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astrocode-workflow",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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/hooks/inject-provider.ts

@@ -3,6 +3,7 @@ import type { SqliteDb } from "../state/db";
 import { selectEligibleInjects } from "../tools/injects";
 import { injectChatPrompt } from "../ui/inject";
 import { nowISO } from "../shared/time";
+import { getActiveRun } from "../workflow/state-machine";
 
 type ChatMessageInput = {
   sessionID: string;
@@ -235,6 +236,29 @@ export function createInjectProvider(opts: {
 
       // 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: string) {
+    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/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