@calltelemetry/openclaw-linear 0.7.0 → 0.8.0

package/src/pipeline/pipeline.ts

@@ -34,6 +34,7 @@ import {
   getActiveDispatch,
 } from "./dispatch-state.js";
 import { type NotifyFn } from "../infra/notify.js";
+import { onProjectIssueCompleted, onProjectIssueStuck } from "./dag-dispatch.js";
 import {
   saveWorkerOutput,
   saveAuditVerdict,
@@ -45,6 +46,7 @@ import {
   resolveOrchestratorWorkspace,
 } from "./artifacts.js";
 import { resolveWatchdogConfig } from "../agent/watchdog.js";
+import { emitDiagnostic } from "../infra/observability.js";
 
 // ---------------------------------------------------------------------------
 // Prompt loading
@@ -58,25 +60,40 @@ interface PromptTemplates {
 
 const DEFAULT_PROMPTS: PromptTemplates = {
   worker: {
-    system: "You are implementing a Linear issue. Post an implementation summary as a Linear comment when done. DO NOT mark the issue as Done.",
-    task: "Implement issue {{identifier}}: {{title}}\n\nIssue body:\n{{description}}\n\nWorktree: {{worktreePath}}",
+    system: "You are a coding worker implementing a Linear issue. Your ONLY job is to write code and return a text summary. Do NOT attempt to update, close, comment on, or modify the Linear issue. Do NOT mark the issue as Done.",
+    task: "Implement issue {{identifier}}: {{title}}\n\nIssue body:\n{{description}}\n\nWorktree: {{worktreePath}}\n\nImplement the solution, run tests, commit your work, and return a text summary.",
   },
   audit: {
     system: "You are an independent auditor. The Linear issue body is the SOURCE OF TRUTH. Worker comments are secondary evidence.",
     task: 'Audit issue {{identifier}}: {{title}}\n\nIssue body:\n{{description}}\n\nWorktree: {{worktreePath}}\n\nReturn JSON verdict: {"pass": true/false, "criteria": [...], "gaps": [...], "testResults": "..."}',
   },
   rework: {
-    addendum: "PREVIOUS AUDIT FAILED (attempt {{attempt}}). Gaps:\n{{gaps}}\n\nAddress these specific issues.",
+    addendum: "PREVIOUS AUDIT FAILED (attempt {{attempt}}). Gaps:\n{{gaps}}\n\nAddress these specific issues. Preserve correct code from prior attempts.",
   },
 };
 
-let _cachedPrompts: PromptTemplates | null = null;
+let _cachedGlobalPrompts: PromptTemplates | null = null;
+const _projectPromptCache = new Map<string, PromptTemplates>();
 
-export function loadPrompts(pluginConfig?: Record<string, unknown>): PromptTemplates {
-  if (_cachedPrompts) return _cachedPrompts;
+/**
+ * Merge two prompt layers. Overlay replaces individual fields per section
+ * (shallow section-level merge, not deep).
+ */
+function mergePromptLayers(base: PromptTemplates, overlay: Partial<PromptTemplates>): PromptTemplates {
+  return {
+    worker: { ...base.worker, ...overlay.worker },
+    audit: { ...base.audit, ...overlay.audit },
+    rework: { ...base.rework, ...overlay.rework },
+  };
+}
 
+/**
+ * Load and parse the raw prompts YAML file (global promptsPath or sidecar).
+ * Returns the parsed object, or null if no file found.
+ * Shared by both pipeline and planner prompt loaders.
+ */
+export function loadRawPromptYaml(pluginConfig?: Record<string, unknown>): Record<string, any> | null {
   try {
-    // Try custom path first
     const customPath = pluginConfig?.promptsPath as string | undefined;
     let raw: string;
 
@@ -86,27 +103,66 @@ export function loadPrompts(pluginConfig?: Record<string, unknown>): PromptTempl
         : customPath;
       raw = readFileSync(resolved, "utf-8");
     } else {
-      // Load from plugin directory (sidecar file)
       const pluginRoot = join(dirname(fileURLToPath(import.meta.url)), "../..");
       raw = readFileSync(join(pluginRoot, "prompts.yaml"), "utf-8");
     }
 
-    const parsed = parseYaml(raw) as Partial<PromptTemplates>;
-    _cachedPrompts = {
-      worker: { ...DEFAULT_PROMPTS.worker, ...parsed.worker },
-      audit: { ...DEFAULT_PROMPTS.audit, ...parsed.audit },
-      rework: { ...DEFAULT_PROMPTS.rework, ...parsed.rework },
-    };
+    return parseYaml(raw) as Record<string, any>;
   } catch {
-    _cachedPrompts = DEFAULT_PROMPTS;
+    return null;
+  }
+}
+
+/**
+ * Load global prompts (layers 1+2: hardcoded defaults + global promptsPath override).
+ * Cached after first load.
+ */
+function loadGlobalPrompts(pluginConfig?: Record<string, unknown>): PromptTemplates {
+  if (_cachedGlobalPrompts) return _cachedGlobalPrompts;
+
+  const parsed = loadRawPromptYaml(pluginConfig);
+  if (parsed) {
+    _cachedGlobalPrompts = mergePromptLayers(DEFAULT_PROMPTS, parsed as Partial<PromptTemplates>);
+  } else {
+    _cachedGlobalPrompts = DEFAULT_PROMPTS;
   }
 
-  return _cachedPrompts;
+  return _cachedGlobalPrompts;
+}
+
+/**
+ * Load prompts with three-layer merge:
+ * 1. Built-in defaults (hardcoded DEFAULT_PROMPTS)
+ * 2. Global override (promptsPath or sidecar prompts.yaml)
+ * 3. Per-project override ({worktreePath}/.claw/prompts.yaml) — optional
+ */
+export function loadPrompts(pluginConfig?: Record<string, unknown>, worktreePath?: string): PromptTemplates {
+  const global = loadGlobalPrompts(pluginConfig);
+
+  if (!worktreePath) return global;
+
+  // Check per-project cache
+  const cached = _projectPromptCache.get(worktreePath);
+  if (cached) return cached;
+
+  // Try loading per-project prompts
+  try {
+    const projectPromptsPath = join(worktreePath, ".claw", "prompts.yaml");
+    const raw = readFileSync(projectPromptsPath, "utf-8");
+    const parsed = parseYaml(raw) as Partial<PromptTemplates>;
+    const merged = mergePromptLayers(global, parsed);
+    _projectPromptCache.set(worktreePath, merged);
+    return merged;
+  } catch {
+    // No per-project override — use global
+    return global;
+  }
 }
 
 /** Clear prompt cache (for testing or after config change) */
 export function clearPromptCache(): void {
-  _cachedPrompts = null;
+  _cachedGlobalPrompts = null;
+  _projectPromptCache.clear();
 }
 
 function renderTemplate(template: string, vars: Record<string, string>): string {
@@ -137,7 +193,7 @@ export function buildWorkerTask(
   worktreePath: string,
   opts?: { attempt?: number; gaps?: string[]; pluginConfig?: Record<string, unknown> },
 ): { system: string; task: string } {
-  const prompts = loadPrompts(opts?.pluginConfig);
+  const prompts = loadPrompts(opts?.pluginConfig, worktreePath);
   const vars: Record<string, string> = {
     identifier: issue.identifier,
     title: issue.title,
@@ -145,7 +201,7 @@ export function buildWorkerTask(
     worktreePath,
     tier: "",
     attempt: String(opts?.attempt ?? 0),
-    gaps: opts?.gaps?.join("\n- ") ?? "",
+    gaps: opts?.gaps?.length ? "- " + opts.gaps.join("\n- ") : "",
   };
 
   let task = renderTemplate(prompts.worker.task, vars);
@@ -167,7 +223,7 @@ export function buildAuditTask(
   worktreePath: string,
   pluginConfig?: Record<string, unknown>,
 ): { system: string; task: string } {
-  const prompts = loadPrompts(pluginConfig);
+  const prompts = loadPrompts(pluginConfig, worktreePath);
   const vars: Record<string, string> = {
     identifier: issue.identifier,
     title: issue.title,
@@ -274,6 +330,7 @@ export async function triggerAudit(
   }
 
   api.logger.info(`${TAG} worker completed, triggering audit (attempt ${dispatch.attempt})`);
+  emitDiagnostic(api, { event: "phase_transition", identifier: dispatch.issueIdentifier, from: "working", to: "auditing", attempt: dispatch.attempt });
 
   // Update .claw/ manifest
   try { updateManifest(dispatch.worktreePath, { status: "auditing", attempts: dispatch.attempt }); } catch {}
@@ -288,7 +345,12 @@ export async function triggerAudit(
   };
 
   // Build audit prompt from YAML templates
-  const auditPrompt = buildAuditTask(issue, dispatch.worktreePath, pluginConfig);
+  // For multi-repo dispatches, render worktreePath as a list of repo→path mappings
+  const effectiveAuditPath = dispatch.worktrees
+    ? dispatch.worktrees.map(w => `${w.repoName}: ${w.path}`).join("\n")
+    : dispatch.worktreePath;
+
+  const auditPrompt = buildAuditTask(issue, effectiveAuditPath, pluginConfig);
 
   // Set Linear label
   await linearApi.emitActivity(dispatch.agentSessionId ?? "", {
@@ -400,6 +462,11 @@ export async function processVerdict(
   const verdict = parseVerdict(auditOutput);
   if (!verdict) {
     api.logger.warn(`${TAG} could not parse audit verdict from output (${auditOutput.length} chars)`);
+    // Post comment so user knows what happened
+    await linearApi.createComment(
+      dispatch.issueId,
+      `## Audit Inconclusive\n\nThe auditor's response couldn't be parsed as a verdict. **Retrying automatically** — this usually resolves itself.\n\n**If it keeps happening:** \`openclaw openclaw-linear prompts validate\`\n\n**Status:** Retrying audit now. No action needed.`,
+    ).catch((err) => api.logger.error(`${TAG} failed to post inconclusive comment: ${err}`));
     // Treat unparseable verdict as failure
     await handleAuditFail(hookCtx, dispatch, {
       pass: false,
@@ -464,7 +531,14 @@ async function handleAuditPass(
     if (summary) {
       writeSummary(dispatch.worktreePath, summary);
       const wsDir = resolveOrchestratorWorkspace(api, pluginConfig);
-      writeDispatchMemory(dispatch.issueIdentifier, summary, wsDir);
+      writeDispatchMemory(dispatch.issueIdentifier, summary, wsDir, {
+        title: dispatch.issueTitle ?? dispatch.issueIdentifier,
+        tier: dispatch.tier,
+        status: "done",
+        project: dispatch.project,
+        attempts: dispatch.attempt + 1,
+        model: dispatch.model,
+      });
       api.logger.info(`${TAG} .claw/ summary and memory written`);
     }
   } catch (err) {
@@ -476,10 +550,11 @@ async function handleAuditPass(
   const summaryExcerpt = summary ? `\n\n**Summary:**\n${summary.slice(0, 2000)}` : "";
   await linearApi.createComment(
     dispatch.issueId,
-    `## Audit Passed\n\n**Criteria verified:**\n${criteriaList}\n\n**Tests:** ${verdict.testResults || "N/A"}${summaryExcerpt}\n\n---\n*Attempt ${dispatch.attempt + 1} — audit passed. Artifacts: \`${dispatch.worktreePath}/.claw/\`*`,
+    `## Done\n\nThis issue has been implemented and verified.\n\n**What was checked:**\n${criteriaList}\n\n**Test results:** ${verdict.testResults || "N/A"}${summaryExcerpt}\n\n---\n*Completed on attempt ${dispatch.attempt + 1}.*\n\n**Next steps:**\n- Review the code: \`cd ${dispatch.worktreePath}\`\n- View artifacts: \`ls ${dispatch.worktreePath}/.claw/\`\n- Create a PR from the worktree branch if one wasn't opened automatically`,
   ).catch((err) => api.logger.error(`${TAG} failed to post audit pass comment: ${err}`));
 
   api.logger.info(`${TAG} audit PASSED — dispatch completed (attempt ${dispatch.attempt})`);
+  emitDiagnostic(api, { event: "verdict_processed", identifier: dispatch.issueIdentifier, phase: "done", attempt: dispatch.attempt });
 
   await notify("audit_pass", {
     identifier: dispatch.issueIdentifier,
@@ -489,6 +564,12 @@ async function handleAuditPass(
     verdict: { pass: true, gaps: [] },
   });
 
+  // DAG cascade: if this issue belongs to a project dispatch, check for newly unblocked issues
+  if (dispatch.project) {
+    void onProjectIssueCompleted(hookCtx, dispatch.project, dispatch.issueIdentifier)
+      .catch((err) => api.logger.error(`${TAG} DAG cascade error: ${err}`));
+  }
+
   clearActiveSession(dispatch.issueId);
 }
 
@@ -531,17 +612,25 @@ async function handleAuditFail(
       if (summary) {
         writeSummary(dispatch.worktreePath, summary);
         const wsDir = resolveOrchestratorWorkspace(api, pluginConfig);
-        writeDispatchMemory(dispatch.issueIdentifier, summary, wsDir);
+        writeDispatchMemory(dispatch.issueIdentifier, summary, wsDir, {
+          title: dispatch.issueTitle ?? dispatch.issueIdentifier,
+          tier: dispatch.tier,
+          status: "stuck",
+          project: dispatch.project,
+          attempts: nextAttempt,
+          model: dispatch.model,
+        });
       }
     } catch {}
 
     const gapsList = verdict.gaps.map((g) => `- ${g}`).join("\n");
     await linearApi.createComment(
       dispatch.issueId,
-      `## Audit Failed — Escalating\n\n**Attempt ${nextAttempt} of ${maxAttempts + 1}**\n\n**Gaps:**\n${gapsList}\n\n**Tests:** ${verdict.testResults || "N/A"}\n\n---\n*Max rework attempts reached. Needs human review. Artifacts: \`${dispatch.worktreePath}/.claw/\`*`,
+      `## Needs Your Help\n\nAll ${nextAttempt} attempts failed. The agent couldn't resolve these issues on its own.\n\n**What went wrong:**\n${gapsList}\n\n**Test results:** ${verdict.testResults || "N/A"}\n\n---\n\n**What you can do:**\n1. **Clarify requirements** — update the issue body with more detail, then re-assign to try again\n2. **Fix it manually** — the agent's work is in the worktree: \`cd ${dispatch.worktreePath}\`\n3. **Force retry** — \`/dispatch retry ${dispatch.issueIdentifier}\`\n4. **View logs** — worker output: \`.claw/worker-*.md\`, audit verdicts: \`.claw/audit-*.json\``,
     ).catch((err) => api.logger.error(`${TAG} failed to post escalation comment: ${err}`));
 
     api.logger.warn(`${TAG} audit FAILED ${nextAttempt}x — escalating to human`);
+    emitDiagnostic(api, { event: "verdict_processed", identifier: dispatch.issueIdentifier, phase: "stuck", attempt: nextAttempt });
 
     await notify("escalation", {
       identifier: dispatch.issueIdentifier,
@@ -552,6 +641,12 @@ async function handleAuditFail(
       verdict: { pass: false, gaps: verdict.gaps },
     });
 
+    // DAG cascade: mark this issue as stuck in the project dispatch
+    if (dispatch.project) {
+      void onProjectIssueStuck(hookCtx, dispatch.project, dispatch.issueIdentifier)
+        .catch((err) => api.logger.error(`${TAG} DAG stuck cascade error: ${err}`));
+    }
+
     return;
   }
 
@@ -575,10 +670,11 @@ async function handleAuditFail(
   const gapsList = verdict.gaps.map((g) => `- ${g}`).join("\n");
   await linearApi.createComment(
     dispatch.issueId,
-    `## Audit Failed — Rework\n\n**Attempt ${nextAttempt} of ${maxAttempts + 1}**\n\n**Gaps:**\n${gapsList}\n\n**Tests:** ${verdict.testResults || "N/A"}\n\n---\n*Reworking: addressing gaps above.*`,
+    `## Needs More Work\n\nThe audit found gaps. **Retrying now** — the worker gets the feedback below as context.\n\n**Attempt ${nextAttempt} of ${maxAttempts + 1}** — ${maxAttempts + 1 - nextAttempt > 0 ? `${maxAttempts + 1 - nextAttempt} more ${maxAttempts + 1 - nextAttempt === 1 ? "retry" : "retries"} if this fails too` : "this is the last attempt"}.\n\n**What needs fixing:**\n${gapsList}\n\n**Test results:** ${verdict.testResults || "N/A"}\n\n**Status:** Worker is restarting with the gaps above as context. No action needed unless all retries fail.`,
   ).catch((err) => api.logger.error(`${TAG} failed to post rework comment: ${err}`));
 
   api.logger.info(`${TAG} audit FAILED — rework attempt ${nextAttempt}/${maxAttempts + 1}`);
+  emitDiagnostic(api, { event: "phase_transition", identifier: dispatch.issueIdentifier, from: "auditing", to: "working", attempt: nextAttempt });
 
   await notify("audit_fail", {
     identifier: dispatch.issueIdentifier,
@@ -643,7 +739,12 @@ export async function spawnWorker(
   };
 
   // Build worker prompt from YAML templates
-  const workerPrompt = buildWorkerTask(issue, dispatch.worktreePath, {
+  // For multi-repo dispatches, render worktreePath as a list of repo→path mappings
+  const effectiveWorkerPath = dispatch.worktrees
+    ? dispatch.worktrees.map(w => `${w.repoName}: ${w.path}`).join("\n")
+    : dispatch.worktreePath;
+
+  const workerPrompt = buildWorkerTask(issue, effectiveWorkerPath, {
     attempt: dispatch.attempt,
     gaps: opts?.gaps,
     pluginConfig,
@@ -698,6 +799,7 @@ export async function spawnWorker(
     const thresholdSec = Math.round(wdConfig.inactivityMs / 1000);
 
     api.logger.warn(`${TAG} worker killed by inactivity watchdog 2x — escalating to stuck`);
+    emitDiagnostic(api, { event: "watchdog_kill", identifier: dispatch.issueIdentifier, attempt: dispatch.attempt });
 
     try {
       appendLog(dispatch.worktreePath, {
@@ -724,8 +826,9 @@ export async function spawnWorker(
 
     await linearApi.createComment(
       dispatch.issueId,
-      `## Watchdog Kill\n\nAgent killed by inactivity watchdog (no I/O for ${thresholdSec}s). ` +
-      `Automatic retry also failed.\n\n---\n*Needs human review. Artifacts: \`${dispatch.worktreePath}/.claw/\`*`,
+      `## Agent Timed Out\n\nThe agent stopped responding for over ${thresholdSec}s. It was automatically restarted, but the retry also timed out.\n\n` +
+      `**What you can do:**\n1. **Try again** — re-assign this issue or \`/dispatch retry ${dispatch.issueIdentifier}\`\n2. **Break it down** — if it keeps timing out, split into smaller issues\n3. **Increase timeout** — set \`inactivitySec\` higher in your agent profile\n\n` +
+      `**Logs:** \`${dispatch.worktreePath}/.claw/log.jsonl\` (look for \`"phase": "watchdog"\`)\n\n**Current status:** Stuck — waiting for you.`,
     ).catch(() => {});
 
     await hookCtx.notify("watchdog_kill", {

package/src/pipeline/planner.test.ts

@@ -251,7 +251,7 @@ describe("handlePlannerTurn", () => {
 
     await handlePlannerTurn(ctx, session, {
       issueId: "issue-1",
-      commentBody: "abandon",
+      commentBody: "abandon planning",
       commentorName: "Tester",
     });
 

package/src/pipeline/planner.ts

@@ -6,11 +6,8 @@
  * - handlePlannerTurn: processes each user comment during planning
  * - runPlanAudit: validates the plan before finalizing
  */
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { parse as parseYaml } from "yaml";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { loadRawPromptYaml } from "./pipeline.js";
 import type { LinearAgentApi } from "../api/linear-api.js";
 import { runAgent } from "../agent/agent.js";
 import {
@@ -56,30 +53,15 @@ function loadPlannerPrompts(pluginConfig?: Record<string, unknown>): PlannerProm
     welcome: "Entering planning mode for **{{projectName}}**. What are the main feature areas?",
   };
 
-  try {
-    const customPath = pluginConfig?.promptsPath as string | undefined;
-    let raw: string;
-
-    if (customPath) {
-      const resolved = customPath.startsWith("~")
-        ? customPath.replace("~", process.env.HOME ?? "")
-        : customPath;
-      raw = readFileSync(resolved, "utf-8");
-    } else {
-      const pluginRoot = join(dirname(fileURLToPath(import.meta.url)), "../..");
-      raw = readFileSync(join(pluginRoot, "prompts.yaml"), "utf-8");
-    }
-
-    const parsed = parseYaml(raw) as any;
-    if (parsed?.planner) {
-      return {
-        system: parsed.planner.system ?? defaults.system,
-        interview: parsed.planner.interview ?? defaults.interview,
-        audit_prompt: parsed.planner.audit_prompt ?? defaults.audit_prompt,
-        welcome: parsed.planner.welcome ?? defaults.welcome,
-      };
-    }
-  } catch { /* use defaults */ }
+  const parsed = loadRawPromptYaml(pluginConfig);
+  if (parsed?.planner) {
+    return {
+      system: parsed.planner.system ?? defaults.system,
+      interview: parsed.planner.interview ?? defaults.interview,
+      audit_prompt: parsed.planner.audit_prompt ?? defaults.audit_prompt,
+      welcome: parsed.planner.welcome ?? defaults.welcome,
+    };
+  }
 
   return defaults;
 }
@@ -142,20 +124,21 @@ export async function initiatePlanningSession(
 // Interview turn
 // ---------------------------------------------------------------------------
 
-const FINALIZE_PATTERN = /\b(finalize\s+plan|finalize|done\s+planning|approve\s+plan|plan\s+looks\s+good)\b/i;
-const ABANDON_PATTERN = /\b(abandon|cancel\s+planning|stop\s+planning|exit\s+planning)\b/i;
+const FINALIZE_PATTERN = /\b(finalize\s+(the\s+)?plan\b|done\s+planning\b(?!\s+\w)|approve\s+(the\s+)?plan\b|plan\s+looks\s+good\b|ready\s+to\s+finalize\b|let'?s\s+finalize\b)/i;
+const ABANDON_PATTERN = /\b(abandon\s+plan(ning)?|cancel\s+plan(ning)?|stop\s+planning|exit\s+planning|quit\s+planning)\b/i;
 
 export async function handlePlannerTurn(
   ctx: PlannerContext,
   session: PlanningSession,
   input: { issueId: string; commentBody: string; commentorName: string },
+  opts?: { onApproved?: (projectId: string) => void },
 ): Promise<void> {
   const { api, linearApi, pluginConfig } = ctx;
   const configPath = pluginConfig?.planningStatePath as string | undefined;
 
   // Detect finalization intent
   if (FINALIZE_PATTERN.test(input.commentBody)) {
-    await runPlanAudit(ctx, session);
+    await runPlanAudit(ctx, session, { onApproved: opts?.onApproved });
     return;
   }
 
@@ -234,6 +217,7 @@ export async function handlePlannerTurn(
 export async function runPlanAudit(
   ctx: PlannerContext,
   session: PlanningSession,
+  opts?: { onApproved?: (projectId: string) => void },
 ): Promise<void> {
   const { api, linearApi, pluginConfig } = ctx;
   const configPath = pluginConfig?.planningStatePath as string | undefined;
@@ -262,6 +246,9 @@ export async function runPlanAudit(
 
     await endPlanningSession(session.projectId, "approved", configPath);
     api.logger.info(`Planning: session approved for ${session.projectName}`);
+
+    // Trigger DAG-based dispatch if callback provided
+    opts?.onApproved?.(session.projectId);
   } else {
     // Post problems and keep planning
     const problemsList = result.problems.map((p) => `- ${p}`).join("\n");

package/src/pipeline/planning-state.ts

@@ -48,48 +48,10 @@ function resolveStatePath(configPath?: string): string {
 }
 
 // ---------------------------------------------------------------------------
-// File locking
+// File locking (shared utility)
 // ---------------------------------------------------------------------------
 
-const LOCK_STALE_MS = 30_000;
-const LOCK_RETRY_MS = 50;
-const LOCK_TIMEOUT_MS = 10_000;
-
-function lockPath(statePath: string): string {
-  return statePath + ".lock";
-}
-
-async function acquireLock(statePath: string): Promise<void> {
-  const lock = lockPath(statePath);
-  const deadline = Date.now() + LOCK_TIMEOUT_MS;
-
-  while (Date.now() < deadline) {
-    try {
-      await fs.writeFile(lock, String(Date.now()), { flag: "wx" });
-      return;
-    } catch (err: any) {
-      if (err.code !== "EEXIST") throw err;
-
-      try {
-        const content = await fs.readFile(lock, "utf-8");
-        const lockTime = Number(content);
-        if (Date.now() - lockTime > LOCK_STALE_MS) {
-          try { await fs.unlink(lock); } catch { /* race */ }
-          continue;
-        }
-      } catch { /* lock disappeared — retry */ }
-
-      await new Promise((r) => setTimeout(r, LOCK_RETRY_MS));
-    }
-  }
-
-  try { await fs.unlink(lockPath(statePath)); } catch { /* ignore */ }
-  await fs.writeFile(lock, String(Date.now()), { flag: "wx" });
-}
-
-async function releaseLock(statePath: string): Promise<void> {
-  try { await fs.unlink(lockPath(statePath)); } catch { /* already removed */ }
-}
+import { acquireLock, releaseLock } from "../infra/file-lock.js";
 
 // ---------------------------------------------------------------------------
 // Read / Write