@kynver-app/runtime 0.1.103 → 0.1.106

package/dist/server/monitor.js

@@ -0,0 +1,1577 @@
+// src/heartbeat.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+
+// src/heartbeat-final-result.ts
+function tryParseJsonObject(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{")) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function embeddedRecordFromProse(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return null;
+  const direct = tryParseJsonObject(trimmed);
+  if (direct) return direct;
+  const candidates = [];
+  const fenceRe = /```(?:json)?\s*([\s\S]*?)```/gi;
+  let fenceMatch;
+  while ((fenceMatch = fenceRe.exec(trimmed)) !== null) {
+    const fromFence = tryParseJsonObject(fenceMatch[1] ?? "");
+    if (fromFence) candidates.push(fromFence);
+  }
+  const firstBrace = trimmed.indexOf("{");
+  const lastBrace = trimmed.lastIndexOf("}");
+  if (firstBrace >= 0 && lastBrace > firstBrace) {
+    const slice = tryParseJsonObject(trimmed.slice(firstBrace, lastBrace + 1));
+    if (slice) candidates.push(slice);
+  }
+  return candidates.length > 0 ? candidates[candidates.length - 1] : null;
+}
+function terminalFinalResultFromHeartbeatRow(row) {
+  const explicit = row.finalResult ?? row.final_result;
+  if (explicit !== void 0 && explicit !== null) {
+    if (typeof explicit === "string") {
+      const embedded2 = embeddedRecordFromProse(explicit);
+      return embedded2 ?? (explicit.trim() || null);
+    }
+    return explicit;
+  }
+  const summary = typeof row.summary === "string" ? row.summary.trim() : "";
+  if (!summary) return null;
+  const embedded = embeddedRecordFromProse(summary);
+  if (embedded) return embedded;
+  return summary;
+}
+
+// src/util.ts
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+function safeJson(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function fileSize(file) {
+  try {
+    return statSync(file).size;
+  } catch {
+    return 0;
+  }
+}
+function fileMtime(file) {
+  try {
+    return statSync(file).mtime.toISOString();
+  } catch {
+    return null;
+  }
+}
+function tailFile(file, lines) {
+  if (!existsSync(file)) return "";
+  const data = readFileSync(file, "utf8");
+  return data.split("\n").slice(-lines).join("\n");
+}
+function isPidAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function latestIso(values) {
+  let best = null;
+  let bestMs = -Infinity;
+  for (const value of values) {
+    if (!value) continue;
+    const ms = Date.parse(value);
+    if (Number.isFinite(ms) && ms > bestMs) {
+      bestMs = ms;
+      best = value;
+    }
+  }
+  return best;
+}
+function secsAgo(ms) {
+  return Math.max(0, Math.round((Date.now() - ms) / 1e3));
+}
+
+// src/heartbeat.ts
+var HEARTBEAT_FUTURE_SKEW_MS = 6e4;
+function isTerminalHeartbeatPhase(phase) {
+  return phase === "complete";
+}
+function terminalFinalResultFromHeartbeat(heartbeat) {
+  if (!isTerminalHeartbeatPhase(heartbeat.lastHeartbeatPhase)) return null;
+  if (heartbeat.terminalFinalResult !== void 0 && heartbeat.terminalFinalResult !== null) {
+    return heartbeat.terminalFinalResult;
+  }
+  const summary = heartbeat.lastHeartbeatSummary?.trim();
+  return summary || "completed";
+}
+function parseHeartbeat(file) {
+  const result = {
+    heartbeatCount: 0,
+    lastHeartbeatAt: null,
+    lastHeartbeatPhase: null,
+    lastHeartbeatSummary: null,
+    terminalFinalResult: null,
+    heartbeatBlocker: null,
+    timestampAnomalies: [],
+    lastBoxResourceSnapshot: null,
+    lastPrEvidence: []
+  };
+  if (!existsSync2(file)) return result;
+  const maxFutureMs = Date.now() + HEARTBEAT_FUTURE_SKEW_MS;
+  const clampedTo = new Date(maxFutureMs).toISOString();
+  const lines = readFileSync2(file, "utf8").split("\n").filter(Boolean);
+  for (const line of lines) {
+    const entry = safeJson(line);
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+    const row = entry;
+    result.heartbeatCount++;
+    if (row.ts) {
+      const ts = String(row.ts);
+      const tsMs = Date.parse(ts);
+      if (Number.isFinite(tsMs) && tsMs > maxFutureMs) {
+        result.timestampAnomalies.push({
+          kind: "future_heartbeat_timestamp",
+          observedAt: ts,
+          clampedTo
+        });
+      } else {
+        result.lastHeartbeatAt = ts;
+      }
+    }
+    if (row.phase !== void 0 && row.phase !== null) result.lastHeartbeatPhase = String(row.phase);
+    if (row.summary !== void 0 && row.summary !== null) result.lastHeartbeatSummary = String(row.summary);
+    if (isTerminalHeartbeatPhase(result.lastHeartbeatPhase)) {
+      result.terminalFinalResult = terminalFinalResultFromHeartbeatRow(row);
+    }
+    result.heartbeatBlocker = row.blocker ? String(row.blocker) : null;
+    if (row.boxResourceSnapshot && typeof row.boxResourceSnapshot === "object" && !Array.isArray(row.boxResourceSnapshot)) {
+      result.lastBoxResourceSnapshot = row.boxResourceSnapshot;
+    }
+    if (Array.isArray(row.prEvidence)) {
+      result.lastPrEvidence = row.prEvidence.filter(
+        (entry2) => !!entry2 && typeof entry2 === "object" && typeof entry2.prUrl === "string"
+      );
+    }
+  }
+  return result;
+}
+
+// src/stream.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+
+// src/repo-search.ts
+var RG_BINARIES = /* @__PURE__ */ new Set(["rg", "ripgrep", "grep"]);
+var RG_OPTS_WITH_VALUE = /* @__PURE__ */ new Set([
+  "-e",
+  "--regexp",
+  "-f",
+  "--file",
+  "-m",
+  "--max-count",
+  "-A",
+  "--after-context",
+  "-B",
+  "--before-context",
+  "-C",
+  "--context",
+  "-g",
+  "--glob",
+  "--iglob"
+]);
+function binaryName(token) {
+  if (!token) return null;
+  const base = token.split("/").pop() ?? token;
+  return base.replace(/\.exe$/i, "").toLowerCase();
+}
+function splitShellWords(input) {
+  if (!input) return [];
+  const words = [];
+  let current = "";
+  let quote;
+  let escaped = false;
+  for (const char of input) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) quote = void 0;
+      else current += char;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current) {
+        words.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (current) words.push(current);
+  return words;
+}
+function isRgArgv(argv) {
+  const bin = binaryName(argv[0]);
+  return Boolean(bin && RG_BINARIES.has(bin));
+}
+function isSingleFileSearchTarget(target) {
+  if (!target || target.includes("/") || target.includes("*")) return false;
+  return /\.(?:json|md|mjs|cjs|js|ts|tsx|yaml|yml)$/iu.test(target);
+}
+function isRgExcludeScopeTarget(target) {
+  if (!target) return false;
+  const t = target.trim();
+  return t.startsWith("!") && !t.includes("/") && !t.endsWith("/**");
+}
+function fixRgGlobToken(token) {
+  if (!token.startsWith("--glob=")) return token;
+  const value = token.slice("--glob=".length);
+  if (value.startsWith("!") && !value.includes("/") && !value.endsWith("/**")) {
+    return `--glob=${value}/**`;
+  }
+  return token;
+}
+function collectRgPositional(argv) {
+  const positional = [];
+  for (let i = 1; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (!token) continue;
+    if (token === "--") {
+      positional.push(...argv.slice(i + 1));
+      break;
+    }
+    if (token.startsWith("-")) {
+      if (token.includes("=")) continue;
+      if (RG_OPTS_WITH_VALUE.has(token)) i += 1;
+      continue;
+    }
+    positional.push(token);
+  }
+  return positional;
+}
+function normalizeRgArgv(argv) {
+  let changed = false;
+  const out = argv.map((token) => {
+    const fixed = fixRgGlobToken(token);
+    if (fixed !== token) changed = true;
+    return fixed;
+  });
+  const positional = collectRgPositional(out);
+  if (positional.length === 2) {
+    const [pattern, target] = positional;
+    if (isSingleFileSearchTarget(target)) {
+      return { argv: [out[0] ?? "rg", "-g", target, pattern, "."], changed: true };
+    }
+  }
+  return { argv: out, changed };
+}
+function normalizeRepoSearchCommand(command) {
+  const trimmed = command.trim();
+  if (!trimmed) return { command: trimmed, changed: false };
+  const joiner = trimmed.includes("&&") ? " && " : trimmed.includes("||") ? " || " : "; ";
+  const stages = trimmed.split(/\s*(?:&&|\|\||;)\s*/u);
+  let changed = false;
+  const normalizedStages = stages.map((stage) => {
+    const argv = splitShellWords(stage.trim());
+    if (!argv.length || !isRgArgv(argv)) return stage;
+    const normalized = normalizeRgArgv(argv);
+    if (normalized.changed) {
+      changed = true;
+      return normalized.argv.join(" ");
+    }
+    return stage;
+  });
+  if (!changed) return { command: trimmed, changed: false };
+  return { command: normalizedStages.join(joiner), changed: true };
+}
+function extractSearchMeta(meta) {
+  if (!meta) return {};
+  const pipelineMatch = meta.match(/search\s+"(.+)"\s+in\s+([^()]+?)(?:\s*\(|$)/iu);
+  if (pipelineMatch) {
+    return { pattern: pipelineMatch[1], target: pipelineMatch[2]?.trim() };
+  }
+  const match = meta.match(/^search\s+"(.+)"\s+in\s+(.+)$/iu);
+  if (!match) return {};
+  return { pattern: match[1], target: match[2]?.trim() };
+}
+function classifyRepoSearchMeta(meta) {
+  const { pattern, target } = extractSearchMeta(meta);
+  if (!pattern) return { kind: "not_repo_search" };
+  if (isRgExcludeScopeTarget(target)) {
+    return { kind: "rg_exclude_syntax", pattern, target };
+  }
+  if (isSingleFileSearchTarget(target)) {
+    return { kind: "bad_scope", pattern, target };
+  }
+  return { kind: "not_repo_search", pattern, target };
+}
+function metaToNormalizedRgCommand(meta) {
+  const { pattern, target } = extractSearchMeta(meta);
+  if (!pattern) return null;
+  if (isRgExcludeScopeTarget(target)) {
+    const glob = `${target.trim()}/**`;
+    return {
+      command: `rg "${pattern}" -g '${glob}' .`,
+      changed: true
+    };
+  }
+  if (target && isSingleFileSearchTarget(target)) {
+    return {
+      command: `rg -g ${target} "${pattern}" .`,
+      changed: true
+    };
+  }
+  return null;
+}
+function formatRepoSearchGuidance(ctx) {
+  if (ctx.kind === "bad_scope" && ctx.pattern?.includes("agent-os-land-pr") && ctx.target === "package.json") {
+    return "Search package.json with a glob from the repo root: `rg -g package.json agent-os-land-pr .` \u2014 or run `node scripts/agent-os-land-pr.mjs <pr-url>` directly.";
+  }
+  if (ctx.kind === "bad_scope" && ctx.pattern && ctx.target) {
+    return `Use \`rg -g '${ctx.target}' ${ctx.pattern} .\` from the repo root instead of treating ${ctx.target} as a folder.`;
+  }
+  if (ctx.kind === "rg_exclude_syntax" && ctx.pattern) {
+    const glob = ctx.target ? `${ctx.target.trim()}/**` : "!node_modules/**";
+    return `Repo search scope \`${ctx.target ?? "!node_modules"}\` is not a valid ripgrep path. Use \`rg "${ctx.pattern}" -g '${glob}' .\` from the repo root (exclude globs need a \`/**\` suffix).`;
+  }
+  if (ctx.kind === "no_matches" && ctx.pattern) {
+    return `No matches for "${ctx.pattern}". Try a broader pattern, drop overly short tokens, or search from the repo root with \`rg "${ctx.pattern}" .\`.`;
+  }
+  return null;
+}
+function extractSearchMetaFromToolLine(line) {
+  const match = line.match(/search\s+"(.+)"\s+in\s+([^()]+?)(?:\s*\(agent\)|\s*failed|$)/iu);
+  if (!match) return null;
+  return `search "${match[1]}" in ${match[2]?.trim()}`;
+}
+function diagnoseRepoSearchFailure(input) {
+  const meta = input.meta?.trim() || (input.command ? extractSearchMetaFromToolLine(input.command) : null) || null;
+  if (meta) {
+    const ctx = classifyRepoSearchMeta(meta);
+    const guidance = formatRepoSearchGuidance(ctx);
+    if (guidance) return guidance;
+    const normalized = metaToNormalizedRgCommand(meta);
+    if (normalized?.changed) {
+      return `Repo search used an invalid scope. Retry with: \`${normalized.command}\`.`;
+    }
+  }
+  if (input.command && /\b(rg|ripgrep)\b/i.test(input.command)) {
+    const normalized = normalizeRepoSearchCommand(input.command);
+    if (normalized.changed) {
+      return `Ripgrep scope may be invalid. Retry with: \`${normalized.command}\`.`;
+    }
+    if (input.exitCode === 1) {
+      return "Ripgrep returned no matches (exit 1). Try a broader pattern or search from the repo root.";
+    }
+  }
+  return null;
+}
+
+// src/shell-command-outcome.ts
+var NPM_AUDIT_RE = /\bnpm\s+audit\b/i;
+var RG_CMD_RE = /\b(rg|ripgrep)\b/i;
+var RG_REAL_ERROR_RE = /\b(error|invalid|unknown|panic|not found)\b/i;
+function tidy(text, max = 200) {
+  const one = text.replace(/\s+/g, " ").trim();
+  return one.length > max ? `${one.slice(0, max - 1)}\u2026` : one;
+}
+function extractJsonObject(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return null;
+  if (trimmed.startsWith("{")) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+    }
+  }
+  const start = trimmed.indexOf("{");
+  const end = trimmed.lastIndexOf("}");
+  if (start >= 0 && end > start) {
+    try {
+      return JSON.parse(trimmed.slice(start, end + 1));
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function summarizeNpmAuditReport(report) {
+  const meta = report.metadata;
+  if (!isRecord(meta)) return null;
+  const vuln = meta.vulnerabilities;
+  if (!isRecord(vuln)) return null;
+  const num = (key) => typeof vuln[key] === "number" ? vuln[key] : 0;
+  const summary = {
+    info: num("info"),
+    low: num("low"),
+    moderate: num("moderate"),
+    high: num("high"),
+    critical: num("critical"),
+    total: num("total")
+  };
+  if (typeof vuln.total !== "number" && !summary.critical && !summary.high && !summary.moderate && !summary.low && !summary.info) {
+    return null;
+  }
+  return summary;
+}
+function formatAuditSummaryLine(audit) {
+  const parts = [];
+  if (audit.critical) parts.push(`${audit.critical} critical`);
+  if (audit.high) parts.push(`${audit.high} high`);
+  if (audit.moderate) parts.push(`${audit.moderate} moderate`);
+  if (audit.low) parts.push(`${audit.low} low`);
+  if (audit.info) parts.push(`${audit.info} info`);
+  const breakdown = parts.length ? parts.join(", ") : "see report";
+  return `npm audit: ${audit.total} vulnerabilit${audit.total === 1 ? "y" : "ies"} (${breakdown}) \u2014 remediation required`;
+}
+function npmAuditFailureReason(report, stderr) {
+  const err = report.error;
+  if (isRecord(err)) {
+    const summary = typeof err.summary === "string" ? err.summary.trim() : "";
+    const code = typeof err.code === "string" ? err.code.trim() : "";
+    if (summary) return code ? `${code}: ${summary}` : summary;
+    if (code) return code;
+  }
+  const detail = typeof report.message === "string" ? report.message.trim() : "";
+  if (detail) return detail;
+  const errTail = stderr.trim();
+  if (errTail) return tidy(errTail.split("\n").find(Boolean) ?? errTail, 160);
+  return "npm audit failed";
+}
+function classifyNpmAuditOutcome(input) {
+  const combined = `${input.stdout}
+${input.stderr}`.trim();
+  const parsed = extractJsonObject(combined);
+  if (!parsed || !isRecord(parsed)) {
+    const tail = tidy(combined || `exit ${input.exitCode}`, 180);
+    return {
+      kind: "command_failure",
+      exitCode: input.exitCode,
+      summary: `npm audit failed (invalid or missing JSON): ${tail}`,
+      parseError: "invalid_json"
+    };
+  }
+  if (isRecord(parsed.error)) {
+    return {
+      kind: "command_failure",
+      exitCode: input.exitCode,
+      summary: `npm audit command failed: ${npmAuditFailureReason(parsed, input.stderr)}`
+    };
+  }
+  const audit = summarizeNpmAuditReport(parsed);
+  if (!audit) {
+    return {
+      kind: "command_failure",
+      exitCode: input.exitCode,
+      summary: "npm audit failed: JSON response missing vulnerability metadata",
+      parseError: "missing_metadata"
+    };
+  }
+  if (input.exitCode === 0 && audit.total === 0) {
+    return {
+      kind: "success",
+      exitCode: 0,
+      summary: "npm audit: no vulnerabilities reported",
+      audit
+    };
+  }
+  return {
+    kind: "audit_findings",
+    exitCode: input.exitCode,
+    summary: formatAuditSummaryLine(audit),
+    audit
+  };
+}
+function isNpmAuditCommand(command) {
+  return NPM_AUDIT_RE.test(command);
+}
+function isRgCommand(command) {
+  return RG_CMD_RE.test(command);
+}
+function classifyRgOutcome(input) {
+  const diagnosis = diagnoseRepoSearchFailure({
+    command: input.command,
+    exitCode: input.exitCode
+  });
+  if (input.exitCode === 0) {
+    return {
+      kind: "success",
+      exitCode: 0,
+      summary: "ripgrep finished (exit 0)"
+    };
+  }
+  if (input.exitCode === 1) {
+    const errText = (input.stderr || input.interleaved).trim();
+    if (errText && RG_REAL_ERROR_RE.test(errText)) {
+      const tail2 = tidy(errText, 160);
+      return {
+        kind: "command_failure",
+        exitCode: 1,
+        summary: diagnosis ?? `ripgrep failed (exit 1): ${tail2}`
+      };
+    }
+    const normalized = normalizeRepoSearchCommand(input.command);
+    const retry = normalized.changed && !diagnosis ? ` Retry with: \`${normalized.command}\`.` : "";
+    return {
+      kind: "search_no_matches",
+      exitCode: 1,
+      summary: diagnosis ?? `ripgrep: no matches (exit 1).${retry} Try a broader pattern or search from the repo root.`
+    };
+  }
+  const tail = tidy(input.interleaved || input.stdout || input.stderr || `exit ${input.exitCode}`, 180);
+  return {
+    kind: "command_failure",
+    exitCode: input.exitCode,
+    summary: diagnosis ?? `ripgrep failed (exit ${input.exitCode}): ${tail}`
+  };
+}
+function classifyShellCommandOutcome(input) {
+  const stdout = input.stdout ?? "";
+  const stderr = input.stderr ?? "";
+  const interleaved = input.interleavedOutput ?? "";
+  if (isNpmAuditCommand(input.command)) {
+    const body = stdout.trim() || interleaved.trim() || stderr.trim();
+    return classifyNpmAuditOutcome({
+      exitCode: input.exitCode,
+      stdout: body,
+      stderr
+    });
+  }
+  if (isRgCommand(input.command)) {
+    return classifyRgOutcome({
+      command: input.command,
+      exitCode: input.exitCode,
+      stdout,
+      stderr,
+      interleaved
+    });
+  }
+  const searchDiagnosis = diagnoseRepoSearchFailure({
+    command: input.command,
+    exitCode: input.exitCode
+  });
+  if (searchDiagnosis && input.exitCode !== 0) {
+    return {
+      kind: "command_failure",
+      exitCode: input.exitCode,
+      summary: searchDiagnosis
+    };
+  }
+  if (input.exitCode === 0) {
+    return {
+      kind: "success",
+      exitCode: 0,
+      summary: `command succeeded (exit 0)`
+    };
+  }
+  const tail = tidy(interleaved || stdout || stderr || `exit ${input.exitCode}`, 180);
+  return {
+    kind: "command_failure",
+    exitCode: input.exitCode,
+    summary: `command failed (exit ${input.exitCode}): ${tail}`
+  };
+}
+
+// src/stream.ts
+function eventTimestampIso(event) {
+  const tsMs = event.timestamp_ms;
+  return event.timestamp || event.ts || (tsMs ? new Date(tsMs).toISOString() : void 0);
+}
+function cursorToolNameFromCall(toolCall) {
+  if (!toolCall) return null;
+  for (const key of Object.keys(toolCall)) {
+    if (key.endsWith("ToolCall")) {
+      const stem = key.slice(0, -"ToolCall".length);
+      return stem.length ? stem : key;
+    }
+  }
+  return null;
+}
+function recordStreamResult(result, event) {
+  result.finalResult = event.result || event.subtype || event.terminal_reason || "completed";
+  if (event.is_error) {
+    result.error = String(event.result || event.api_error_status || "stream result error");
+  }
+}
+function shellPayloadFromCursorEvent(event) {
+  if (event.type !== "tool_call" || event.subtype !== "completed") return null;
+  const toolCall = event.tool_call && typeof event.tool_call === "object" && !Array.isArray(event.tool_call) ? event.tool_call : null;
+  const shell = toolCall?.shellToolCall;
+  if (!shell || typeof shell !== "object" || Array.isArray(shell)) return null;
+  const shellObj = shell;
+  const args = shellObj.args;
+  const command = args && typeof args === "object" && !Array.isArray(args) && typeof args.command === "string" ? String(args.command) : "";
+  const result = shellObj.result;
+  if (!result || typeof result !== "object" || Array.isArray(result)) return null;
+  const body = result.success ?? result.failure;
+  if (!body || typeof body !== "object" || Array.isArray(body)) return null;
+  const row = body;
+  const exitCode = typeof row.exitCode === "number" ? row.exitCode : 0;
+  return {
+    command,
+    exitCode,
+    stdout: typeof row.stdout === "string" ? row.stdout : "",
+    stderr: typeof row.stderr === "string" ? row.stderr : "",
+    interleaved: typeof row.interleavedOutput === "string" ? row.interleavedOutput : ""
+  };
+}
+function applyShellOutcome(parsed, outcome) {
+  if (outcome.kind === "success" || outcome.kind === "search_no_matches") return;
+  parsed.lastShellOutcome = outcome;
+}
+function parseHarnessStream(file) {
+  const result = {
+    firstEventAt: null,
+    lastEventAt: null,
+    currentTool: null,
+    finalResult: null,
+    error: null,
+    lastShellOutcome: null
+  };
+  if (!existsSync3(file)) return result;
+  const lines = readFileSync3(file, "utf8").split("\n").filter(Boolean);
+  for (const line of lines) {
+    const event = safeJson(line);
+    if (!event) continue;
+    const ts = eventTimestampIso(event);
+    if (ts) {
+      result.firstEventAt ||= ts;
+      result.lastEventAt = ts;
+    }
+    if (event.type === "stream_event" && event.event && typeof event.event === "object" && event.event.type === "content_block_start") {
+      const block = event.event.content_block;
+      if (block?.type === "tool_use") result.currentTool = String(block.name || "tool");
+    }
+    if (event.type === "assistant" && event.message && typeof event.message === "object") {
+      const content = event.message.content;
+      if (Array.isArray(content)) {
+        const tool = content.find((item) => item?.type === "tool_use");
+        if (tool) result.currentTool = String(tool.name || result.currentTool);
+      }
+    }
+    if (event.type === "tool_call" && event.subtype === "started") {
+      const toolCall = event.tool_call && typeof event.tool_call === "object" && !Array.isArray(event.tool_call) ? event.tool_call : void 0;
+      const name = cursorToolNameFromCall(toolCall);
+      if (name) result.currentTool = name;
+    }
+    const shell = shellPayloadFromCursorEvent(event);
+    if (shell) {
+      applyShellOutcome(
+        result,
+        classifyShellCommandOutcome({
+          command: shell.command,
+          exitCode: shell.exitCode,
+          stdout: shell.stdout,
+          stderr: shell.stderr,
+          interleavedOutput: shell.interleaved
+        })
+      );
+    }
+    if (event.type === "result") {
+      recordStreamResult(result, event);
+    }
+  }
+  return result;
+}
+
+// src/exit-classify.ts
+var FAILURE_PATTERNS = [
+  {
+    test: /\b(?:invalid|unknown|unsupported|unrecognized)\b[^.\n]*\bmodel\b/i,
+    label: "provider rejected the requested model"
+  },
+  {
+    test: /\bmodel\b[^.\n]*\b(?:not\s+(?:found|supported|available|recognized|valid)|is\s+not\s+valid|does\s+not\s+exist)/i,
+    label: "provider rejected the requested model"
+  },
+  {
+    test: /\b(?:did you mean|available models|choose (?:a|one of)|supported models)\b/i,
+    label: "provider rejected the requested model"
+  },
+  {
+    test: /model preflight failed/i,
+    label: "model/provider preflight failed"
+  },
+  {
+    test: /\b(?:command not found|ENOENT|is the .*CLI on PATH|executable not found|no such file or directory)\b/i,
+    label: "provider CLI is missing or not on PATH"
+  },
+  {
+    test: /\bfailed to spawn\b/i,
+    label: "provider failed to spawn the worker process"
+  },
+  {
+    test: /\b(?:not logged in|unauthorized|authentication (?:failed|required)|invalid api key|missing api key|401)\b/i,
+    label: "provider authentication failed"
+  }
+];
+function tidy2(errorText, max = 240) {
+  const oneLine2 = errorText.replace(/\s+/g, " ").trim();
+  return oneLine2.length > max ? `${oneLine2.slice(0, max - 1)}\u2026` : oneLine2;
+}
+function classifyExitFailure(errorText) {
+  const text = (errorText ?? "").trim();
+  if (!text) return null;
+  for (const pattern of FAILURE_PATTERNS) {
+    if (pattern.test.test(text)) {
+      return { blocked: true, reason: `${pattern.label}: ${tidy2(text)}` };
+    }
+  }
+  return null;
+}
+
+// src/exited-salvage.ts
+function trimOrNull(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length ? trimmed : null;
+}
+function hasFinalResult(value) {
+  if (value === void 0 || value === null) return false;
+  if (typeof value === "string") return value.trim().length > 0;
+  if (typeof value === "boolean") return value;
+  if (Array.isArray(value)) return value.length > 0;
+  if (typeof value === "object") return Object.keys(value).length > 0;
+  return true;
+}
+function committedHeadFromAncestry(ancestry) {
+  if (!ancestry?.checked) return null;
+  if (ancestry.headIsAncestorOfBase !== false) return null;
+  return trimOrNull(ancestry.head);
+}
+function buildAttentionReason(kind, uncommittedCount, headCommit) {
+  const parts = ["exited_with_changes_salvage"];
+  if (kind === "uncommitted" || kind === "both") {
+    parts.push(
+      `${uncommittedCount} uncommitted change${uncommittedCount === 1 ? "" : "s"} with no final result`
+    );
+  }
+  if ((kind === "committed_ahead" || kind === "both") && headCommit) {
+    const sha = headCommit.length > 12 ? headCommit.slice(0, 12) : headCommit;
+    parts.push(`commit ${sha} ahead of base with no final result`);
+  }
+  parts.push("review worktree \u2014 commit, open a PR, or run a salvage worker before discarding");
+  return parts.join(": ");
+}
+function assessExitedWorkerSalvage(input) {
+  if (input.alive || hasFinalResult(input.finalResult)) return null;
+  const uncommittedCount = (input.changedFiles ?? []).filter((line) => line.trim()).length;
+  const headCommit = trimOrNull(input.headCommit) ?? committedHeadFromAncestry(input.gitAncestry);
+  const hasUncommitted = uncommittedCount > 0;
+  const hasCommittedAhead = Boolean(headCommit);
+  if (!hasUncommitted && !hasCommittedAhead) {
+    return {
+      kind: "none",
+      salvageable: false,
+      uncommittedCount: 0,
+      headCommit: null,
+      attentionReason: "process exited without a final result"
+    };
+  }
+  const kind = hasUncommitted && hasCommittedAhead ? "both" : hasUncommitted ? "uncommitted" : "committed_ahead";
+  return {
+    kind,
+    salvageable: true,
+    uncommittedCount,
+    headCommit,
+    attentionReason: buildAttentionReason(kind, uncommittedCount, headCommit)
+  };
+}
+
+// src/git.ts
+import { spawnSync } from "node:child_process";
+
+// src/worker-env.ts
+var FORBIDDEN_WORKER_ENV_KEYS = [
+  "ANTHROPIC_API_KEY",
+  "ANALYST_API_KEY",
+  "RECRUITER_API_KEY",
+  "AUTH_SECRET",
+  "NEXTAUTH_SECRET",
+  "DATABASE_URL",
+  "PRODUCTION_DATABASE_URL",
+  "KYNVER_PRODUCTION_DATABASE_URL",
+  "REDIS_URL",
+  "GOOGLE_CLIENT_SECRET",
+  "GITHUB_CLIENT_SECRET",
+  "KYNVER_API_KEY",
+  "KYNVER_SERVICE_SECRET",
+  "KYNVER_RUNTIME_SECRET",
+  "KYNVER_CRON_SECRET",
+  "OPENCLAW_CRON_SECRET",
+  "QSTASH_TOKEN",
+  "QSTASH_CURRENT_SIGNING_KEY",
+  "QSTASH_NEXT_SIGNING_KEY",
+  "TOOL_SECRETS_KEK",
+  "TOOL_EXECUTOR_DISPATCH_SECRET",
+  "CLOUDFLARE_API_TOKEN",
+  "STRIPE_SECRET_KEY",
+  "STRIPE_WEBHOOK_SECRET",
+  "STRIPE_IDENTITY_WEBHOOK_SECRET",
+  "VOYAGE_API_KEY",
+  "PERPLEXITY_API_KEY",
+  "FRED_API_KEY",
+  "FMP_API_KEY",
+  "CURSOR_API_KEY"
+];
+var FORBIDDEN_KEY_SET = new Set(FORBIDDEN_WORKER_ENV_KEYS);
+
+// src/git.ts
+function git(cwd, args, options = {}) {
+  const res = spawnSync("git", args, { cwd, encoding: "utf8" });
+  if (res.status !== 0 && !options.allowFailure) {
+    const message = `git ${args.join(" ")} failed: ${res.stderr || res.stdout}`;
+    if (options.throwError) throw new Error(message);
+    fail(message);
+  }
+  return res.stdout || "";
+}
+function gitStatusShort(worktreePath) {
+  return git(worktreePath, ["status", "--short"], { allowFailure: true }).split("\n").map((line) => line.trim()).filter(Boolean);
+}
+function gitCapture(cwd, args) {
+  try {
+    const res = spawnSync("git", args, { cwd, encoding: "utf8" });
+    return {
+      status: res.status,
+      stdout: res.stdout || "",
+      stderr: res.stderr || "",
+      error: res.error ? res.error.message : null
+    };
+  } catch (error) {
+    return {
+      status: null,
+      stdout: "",
+      stderr: "",
+      error: error.message
+    };
+  }
+}
+function gitIsAncestor(cwd, ancestor, descendant) {
+  const res = gitCapture(cwd, ["merge-base", "--is-ancestor", ancestor, descendant]);
+  if (res.status === 0) return { isAncestor: true, error: null };
+  if (res.status === 1) return { isAncestor: false, error: null };
+  return { isAncestor: null, error: res.error || res.stderr || res.stdout || `git exited ${res.status}` };
+}
+function computeGitAncestry(worktreePath, baseOrOptions = "origin/main") {
+  const options = typeof baseOrOptions === "string" ? { base: baseOrOptions } : baseOrOptions;
+  const baseLabel = options.baseCommit?.trim() || options.base?.trim() || "origin/main";
+  const pinnedBaseCommit = options.baseCommit?.trim() || null;
+  if (!worktreePath) {
+    return unknownAncestry(baseLabel, "missing worktree path");
+  }
+  const head = gitCapture(worktreePath, ["rev-parse", "HEAD"]);
+  if (head.status !== 0) {
+    return unknownAncestry(baseLabel, head.error || head.stderr || head.stdout || "failed to resolve HEAD");
+  }
+  let baseSha;
+  if (pinnedBaseCommit) {
+    baseSha = pinnedBaseCommit;
+  } else {
+    const baseHead = gitCapture(worktreePath, ["rev-parse", baseLabel]);
+    if (baseHead.status !== 0) {
+      return unknownAncestry(
+        baseLabel,
+        baseHead.error || baseHead.stderr || baseHead.stdout || `failed to resolve ${baseLabel}`,
+        head.stdout.trim()
+      );
+    }
+    baseSha = baseHead.stdout.trim();
+  }
+  const headSha = head.stdout.trim();
+  if (headSha === baseSha) {
+    return {
+      checked: true,
+      base: baseLabel,
+      head: headSha,
+      baseHead: baseSha,
+      baseIsAncestorOfHead: true,
+      headIsAncestorOfBase: true,
+      relation: "synced"
+    };
+  }
+  const baseIsAncestorOfHead = gitIsAncestor(worktreePath, baseSha, headSha);
+  const headIsAncestorOfBase = gitIsAncestor(worktreePath, headSha, baseSha);
+  const error = baseIsAncestorOfHead.error || headIsAncestorOfBase.error || void 0;
+  if (baseIsAncestorOfHead.isAncestor == null || headIsAncestorOfBase.isAncestor == null) {
+    return {
+      checked: false,
+      base: baseLabel,
+      head: headSha,
+      baseHead: baseSha,
+      baseIsAncestorOfHead: baseIsAncestorOfHead.isAncestor,
+      headIsAncestorOfBase: headIsAncestorOfBase.isAncestor,
+      relation: "unknown",
+      ...error ? { error } : {}
+    };
+  }
+  const relation = baseIsAncestorOfHead.isAncestor ? "ahead" : headIsAncestorOfBase.isAncestor ? "merged" : "diverged";
+  return {
+    checked: true,
+    base: baseLabel,
+    head: headSha,
+    baseHead: baseSha,
+    baseIsAncestorOfHead: baseIsAncestorOfHead.isAncestor,
+    headIsAncestorOfBase: headIsAncestorOfBase.isAncestor,
+    relation,
+    ...error ? { error } : {}
+  };
+}
+function unknownAncestry(base, error, head = null) {
+  return {
+    checked: false,
+    base,
+    head,
+    baseHead: null,
+    baseIsAncestorOfHead: null,
+    headIsAncestorOfBase: null,
+    relation: "unknown",
+    error
+  };
+}
+
+// src/landing-gate.ts
+function trimOrNull2(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length ? trimmed : null;
+}
+function hasFinalResult2(value) {
+  if (value === void 0 || value === null) return false;
+  if (typeof value === "string") return value.trim().length > 0;
+  if (typeof value === "boolean") return value;
+  if (Array.isArray(value)) return value.length > 0;
+  if (typeof value === "object") return Object.keys(value).length > 0;
+  return true;
+}
+function hasCommittedLandingRef(snapshot) {
+  if (trimOrNull2(snapshot.headCommit)) return true;
+  if (trimOrNull2(snapshot.prUrl)) return true;
+  if (trimOrNull2(snapshot.artifactBundlePath)) return true;
+  if (trimOrNull2(snapshot.patchPath)) return true;
+  const ancestry = snapshot.gitAncestry;
+  if (ancestry?.checked && ancestry.headIsAncestorOfBase === false && trimOrNull2(ancestry.head)) {
+    return true;
+  }
+  return false;
+}
+function assessWorkerLanding(snapshot) {
+  if (!hasFinalResult2(snapshot.finalResult)) return { blocked: false };
+  if (snapshot.changedFiles.length === 0) return { blocked: false };
+  if (!hasCommittedLandingRef(snapshot)) {
+    return {
+      blocked: true,
+      reason: "dirty_worktree_no_pr",
+      detail: `Worktree has ${snapshot.changedFiles.length} uncommitted change(s) with no commit or PR; commit, open a PR, or discard before landing`
+    };
+  }
+  return {
+    blocked: true,
+    detail: `Worktree has ${snapshot.changedFiles.length} uncommitted change(s); commit or discard before landing`
+  };
+}
+function landingAttentionReason(verdict) {
+  if (!verdict.blocked) return void 0;
+  return verdict.detail ?? verdict.reason ?? "dirty_worktree_no_pr";
+}
+
+// src/worker-final-result-embed.ts
+function tryParseJsonObject2(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{")) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function reconciliationEntryCount(record) {
+  const raw = record.targetPrReconciliation ?? record.target_pr_reconciliation ?? record.targetPrs ?? record.target_prs;
+  return Array.isArray(raw) ? raw.length : 0;
+}
+function extractEmbeddedWorkerFinalResultRecord(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  const direct = tryParseJsonObject2(trimmed);
+  if (direct) return direct;
+  const candidates = [];
+  const fenceRe = /```(?:json)?\s*([\s\S]*?)```/gi;
+  let fenceMatch;
+  while ((fenceMatch = fenceRe.exec(trimmed)) !== null) {
+    const fromFence = tryParseJsonObject2(fenceMatch[1] ?? "");
+    if (fromFence) candidates.push(fromFence);
+  }
+  const firstBrace = trimmed.indexOf("{");
+  const lastBrace = trimmed.lastIndexOf("}");
+  if (firstBrace >= 0 && lastBrace > firstBrace) {
+    const slice = tryParseJsonObject2(trimmed.slice(firstBrace, lastBrace + 1));
+    if (slice) candidates.push(slice);
+  }
+  if (candidates.length === 0) return null;
+  let best = candidates[candidates.length - 1];
+  let bestScore = reconciliationEntryCount(best);
+  for (const candidate of candidates) {
+    const score = reconciliationEntryCount(candidate);
+    if (score > bestScore) {
+      best = candidate;
+      bestScore = score;
+    }
+  }
+  return best;
+}
+
+// src/landing-contract-gate.ts
+function trimOrNull3(value) {
+  if (typeof value !== "string") return null;
+  const t = value.trim();
+  return t.length ? t : null;
+}
+function hasFinalResult3(value) {
+  if (value === void 0 || value === null) return false;
+  if (typeof value === "string") return value.trim().length > 0;
+  if (typeof value === "object") return Object.keys(value).length > 0;
+  return true;
+}
+function normalizePrUrl(url) {
+  const m = url.trim().match(/github\.com\/([^/]+\/[^/]+)\/(?:pull|pulls)\/(\d+)/i);
+  if (!m) return trimOrNull3(url);
+  return `https://github.com/${m[1]}/pull/${m[2]}`;
+}
+function prUrlSetKey(url) {
+  const m = url.trim().match(/github\.com\/([^/]+\/[^/]+)\/(?:pull|pulls)\/(\d+)/i);
+  if (!m) return url.trim().toLowerCase();
+  return `${m[1].toLowerCase()}/pull/${m[2]}`;
+}
+function parseReconciliation(finalResult) {
+  let record = null;
+  if (typeof finalResult === "string") {
+    const embedded = extractEmbeddedWorkerFinalResultRecord(finalResult);
+    if (embedded) record = embedded;
+  } else if (finalResult && typeof finalResult === "object" && !Array.isArray(finalResult)) {
+    record = finalResult;
+  }
+  if (!record) return [];
+  const raw = record.targetPrReconciliation ?? record.target_pr_reconciliation;
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const item of raw) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+    const row = item;
+    const prUrl = normalizePrUrl(String(row.prUrl ?? row.pr_url ?? ""));
+    const outcome = trimOrNull3(row.outcome);
+    if (!prUrl || outcome !== "merged" && outcome !== "skipped" && outcome !== "blocked") continue;
+    out.push({
+      prUrl,
+      outcome,
+      mergeCommit: trimOrNull3(row.mergeCommit ?? row.merge_commit),
+      reason: trimOrNull3(row.reason)
+    });
+  }
+  return out;
+}
+function workerAttachedPrUrls(snapshot, finalResult) {
+  const urls = [];
+  const fromSnapshot = normalizePrUrl(trimOrNull3(snapshot.prUrl) ?? "");
+  if (fromSnapshot) urls.push(fromSnapshot);
+  if (finalResult && typeof finalResult === "object" && !Array.isArray(finalResult)) {
+    const record = finalResult;
+    const pr = normalizePrUrl(String(record.prUrl ?? record.pr_url ?? ""));
+    if (pr) urls.push(pr);
+  }
+  return [...new Set(urls)];
+}
+function assessWorkerLandingContract(input) {
+  const { contract, snapshot } = input;
+  const finalResult = input.finalResult ?? snapshot.finalResult;
+  if (!contract.landingOnly && contract.targetPrUrls.length === 0 && !contract.repairEnforceOriginalPr) {
+    return { blocked: false };
+  }
+  if (!hasFinalResult3(finalResult)) {
+    const requiresEarly = contract.requiresTargetPrReconciliation ?? (contract.landingOnly || Boolean(contract.repairEnforceOriginalPr) || contract.targetPrUrls.length > 0);
+    if (requiresEarly && contract.targetPrUrls.length > 0) {
+      return {
+        blocked: true,
+        reason: "missing_target_pr_reconciliation",
+        detail: `Final result required to reconcile target PR(s): ${contract.targetPrUrls.join(", ")}`
+      };
+    }
+    return { blocked: false };
+  }
+  const requiresTargetPrReconciliation = contract.requiresTargetPrReconciliation ?? (contract.landingOnly || Boolean(contract.repairEnforceOriginalPr) || contract.targetPrUrls.length > 0);
+  if (!requiresTargetPrReconciliation && !contract.repairEnforceOriginalPr) {
+    return { blocked: false };
+  }
+  const repairTarget = contract.repairEnforceOriginalPr ? normalizePrUrl(trimOrNull3(contract.targetPrUrl) ?? "") ?? (contract.targetPrUrls.length === 1 ? normalizePrUrl(contract.targetPrUrls[0]) : null) : null;
+  if (repairTarget) {
+    const workerPrs = workerAttachedPrUrls(snapshot, finalResult);
+    const supersedes = finalResult && typeof finalResult === "object" && !Array.isArray(finalResult) && finalResult.supersedesOriginalTargetPr === true;
+    if (!supersedes) {
+      for (const pr of workerPrs) {
+        if (pr !== repairTarget) {
+          return {
+            blocked: true,
+            reason: "duplicate_repair_pr",
+            detail: `Repair worker opened or attached PR ${pr} instead of canonical target ${repairTarget}`
+          };
+        }
+      }
+    }
+    const reconciliation2 = parseReconciliation(finalResult);
+    const entry = reconciliation2.find((r) => r.prUrl === repairTarget);
+    if (!entry || entry.outcome !== "merged" && !(entry.reason?.trim() && (entry.outcome === "skipped" || entry.outcome === "blocked"))) {
+      return {
+        blocked: true,
+        reason: "missing_repair_target_reconciliation",
+        detail: `Repair worker must reconcile target PR ${repairTarget}`
+      };
+    }
+  }
+  const reconciliation = parseReconciliation(finalResult);
+  const byUrl = new Map(
+    reconciliation.map((r) => [prUrlSetKey(r.prUrl), r])
+  );
+  const targetSet = new Set(
+    contract.targetPrUrls.map((u) => prUrlSetKey(normalizePrUrl(u) ?? u)).filter(Boolean)
+  );
+  const attachedPrs = workerAttachedPrUrls(snapshot, finalResult);
+  if (contract.landingOnly) {
+    for (const pr of attachedPrs) {
+      if (targetSet.size > 0 && !targetSet.has(prUrlSetKey(pr))) {
+        return {
+          blocked: true,
+          reason: "unrelated_implementation_pr",
+          detail: `Landing-only worker attached unrelated PR ${pr}`
+        };
+      }
+      if (targetSet.size === 0) {
+        return {
+          blocked: true,
+          reason: "unrelated_implementation_pr",
+          detail: "Landing-only worker must not open new implementation PRs"
+        };
+      }
+    }
+  }
+  if (contract.targetPrUrls.length === 0) return { blocked: false };
+  const missing = [];
+  for (const target of contract.targetPrUrls) {
+    const key = prUrlSetKey(normalizePrUrl(target) ?? target);
+    const entry = byUrl.get(key);
+    if (!entry) {
+      missing.push(key);
+      continue;
+    }
+    if (entry.outcome !== "merged" && !entry.reason?.trim()) {
+      missing.push(key);
+    }
+  }
+  if (missing.length > 0) {
+    return {
+      blocked: true,
+      reason: missing.every((u) => byUrl.has(u)) ? "incomplete_target_pr_landing" : "missing_target_pr_reconciliation",
+      detail: `Target PR reconciliation incomplete: ${missing.join(", ")}`
+    };
+  }
+  return { blocked: false };
+}
+function landingContractAttentionReason(verdict) {
+  if (!verdict.blocked) return void 0;
+  return verdict.detail ?? verdict.reason;
+}
+
+// src/status.ts
+var NO_START_MS = 18e4;
+var STALE_MS = 6e5;
+function computeAttention(input) {
+  const now = Date.now();
+  if (input.completionBlocker && !isSkippedTerminalCompletionBlocker(input.completionBlocker)) {
+    return { state: "blocked", reason: input.completionBlocker };
+  }
+  if (input.finalResult) {
+    if (input.localOnly && hasMergedTargetPrReconciliation(input.finalResult)) {
+      return { state: "done", reason: "local-only worker superseded by merged PR" };
+    }
+    const landingSnapshot = {
+      finalResult: input.finalResult,
+      changedFiles: input.changedFiles ?? [],
+      gitAncestry: input.gitAncestry ?? null,
+      prUrl: input.prUrl ?? null
+    };
+    const landing = assessWorkerLanding(landingSnapshot);
+    if (landing.blocked) {
+      const detail = landingAttentionReason(landing);
+      return {
+        state: "needs_attention",
+        reason: landing.reason ? `landing blocked (${landing.reason}): ${detail}` : `landing blocked: ${detail}`
+      };
+    }
+    if (input.landingContract) {
+      const contractVerdict = assessWorkerLandingContract({
+        contract: input.landingContract,
+        snapshot: landingSnapshot,
+        finalResult: input.finalResult
+      });
+      const contractDetail = landingContractAttentionReason(contractVerdict);
+      if (contractDetail) {
+        return {
+          state: "needs_attention",
+          reason: contractVerdict.reason ? `landing contract (${contractVerdict.reason}): ${contractDetail}` : `landing contract: ${contractDetail}`
+        };
+      }
+    }
+    return { state: "done", reason: "final result recorded" };
+  }
+  if (!input.alive) {
+    if (isAbandonedEmptyWorker(input)) {
+      return { state: "done", reason: "empty abandoned worker record" };
+    }
+    const classified = classifyExitFailure(input.error);
+    if (classified) return { state: "blocked", reason: classified.reason };
+    const salvage = assessExitedWorkerSalvage({
+      alive: false,
+      finalResult: null,
+      changedFiles: input.changedFiles,
+      gitAncestry: input.gitAncestry
+    });
+    if (salvage?.salvageable) {
+      const tail2 = input.error?.trim();
+      return {
+        state: "needs_attention",
+        reason: tail2 ? `${salvage.attentionReason} (${tail2})` : salvage.attentionReason
+      };
+    }
+    const tail = input.error?.trim();
+    return {
+      state: "needs_attention",
+      reason: tail ? `process exited without a final result: ${tail}` : salvage?.attentionReason ?? "process exited without a final result"
+    };
+  }
+  if (input.heartbeatBlocker) {
+    return { state: "blocked", reason: `worker heartbeat reported blocker: ${input.heartbeatBlocker}` };
+  }
+  const startMs = input.startedAt ? Date.parse(input.startedAt) : NaN;
+  if (!input.firstEventAt && input.stdoutBytes === 0 && input.heartbeatBytes === 0 && Number.isFinite(startMs) && now - startMs > NO_START_MS) {
+    return { state: "needs_attention", reason: `no first stream event ${secsAgo(startMs)}s after start` };
+  }
+  const actMs = input.lastActivityAt ? Date.parse(input.lastActivityAt) : NaN;
+  if (Number.isFinite(actMs) && now - actMs > STALE_MS) {
+    return { state: "stale", reason: `no log/event/heartbeat activity for ${secsAgo(actMs)}s` };
+  }
+  return { state: "ok", reason: "recent activity" };
+}
+function isSkippedTerminalCompletionBlocker(reason) {
+  const text = reason?.trim();
+  if (!text) return false;
+  return /completion acknowledged but board not advanced/i.test(text) && /task already terminal/i.test(text);
+}
+function isAbandonedEmptyWorker(input) {
+  if (input.finalResult) return false;
+  if (input.taskId || input.agentOsId) return false;
+  if (input.stdoutBytes > 0 || (input.stderrBytes ?? 0) > 0 || input.heartbeatBytes > 0) return false;
+  if (input.error?.trim()) return false;
+  if ((input.changedFiles ?? []).some((line) => line.trim())) return false;
+  return /empty worker dir|marked abandoned/i.test(input.reconcileReason ?? "");
+}
+function hasMergedTargetPrReconciliation(value) {
+  let record = null;
+  if (typeof value === "string") record = extractEmbeddedWorkerFinalResultRecord(value);
+  else if (value && typeof value === "object" && !Array.isArray(value)) record = value;
+  if (!record) return false;
+  const raw = record.targetPrReconciliation ?? record.target_pr_reconciliation;
+  if (!Array.isArray(raw)) return false;
+  return raw.some((item) => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return false;
+    return String(item.outcome ?? "").trim() === "merged";
+  });
+}
+function resolveFinalResult(worker, parsedFinalResult, heartbeat) {
+  const ackSnapshot = worker.completionSnapshot?.finalResult;
+  if (worker.completionAckSource === "local-pr-merged-reconcile" && ackSnapshot !== void 0 && ackSnapshot !== null) {
+    return ackSnapshot;
+  }
+  if (parsedFinalResult) return parsedFinalResult;
+  if (ackSnapshot !== void 0 && ackSnapshot !== null) return ackSnapshot;
+  return terminalFinalResultFromHeartbeat(heartbeat);
+}
+function computeWorkerStatus(worker, options = {}) {
+  const parsed = parseHarnessStream(worker.stdoutPath);
+  const heartbeat = parseHeartbeat(worker.heartbeatPath);
+  const completionAcknowledged = typeof worker.completionReportedAt === "string" && worker.completionReportedAt.trim().length > 0;
+  const finalResult = resolveFinalResult(worker, parsed.finalResult, heartbeat);
+  const alive = completionAcknowledged ? false : isPidAlive(worker.pid);
+  const stdoutBytes = fileSize(worker.stdoutPath);
+  const stderrBytes = fileSize(worker.stderrPath);
+  const heartbeatBytes = fileSize(worker.heartbeatPath);
+  const changedFiles = gitStatusShort(worker.worktreePath);
+  const gitAncestry = computeGitAncestry(worker.worktreePath, {
+    base: options.base,
+    baseCommit: options.baseCommit
+  });
+  const lastActivityAt = latestIso([
+    parsed.lastEventAt,
+    heartbeat.lastHeartbeatAt,
+    fileMtime(worker.stdoutPath),
+    fileMtime(worker.stderrPath),
+    fileMtime(worker.heartbeatPath)
+  ]);
+  const error = parsed.error || (!alive && !finalResult ? tailFile(worker.stderrPath, 10).trim() || void 0 : void 0);
+  const completionBlocker = typeof worker.completionBlocker === "string" && worker.completionBlocker.trim() ? worker.completionBlocker.trim() : null;
+  const effectiveCompletionBlocker = isSkippedTerminalCompletionBlocker(completionBlocker) ? null : completionBlocker;
+  const landingContract = worker.repairTargetPrUrl ? {
+    landingOnly: false,
+    targetPrUrls: [worker.repairTargetPrUrl],
+    targetPrUrl: worker.repairTargetPrUrl,
+    repairEnforceOriginalPr: true
+  } : null;
+  const attention = computeAttention({
+    alive,
+    finalResult,
+    firstEventAt: parsed.firstEventAt,
+    stdoutBytes,
+    stderrBytes,
+    heartbeatBytes,
+    lastActivityAt,
+    heartbeatBlocker: heartbeat.heartbeatBlocker,
+    startedAt: worker.startedAt,
+    error,
+    changedFiles,
+    gitAncestry,
+    completionBlocker: effectiveCompletionBlocker,
+    landingContract,
+    prUrl: worker.repairTargetPrUrl ?? worker.taskPrUrl ?? null,
+    localOnly: worker.localOnly === true,
+    taskId: worker.taskId ?? null,
+    agentOsId: worker.agentOsId ?? null,
+    reconcileReason: worker.reconcileReason ?? null
+  });
+  const workerStatusLabel = effectiveCompletionBlocker || attention.state === "blocked" ? "blocked" : completionAcknowledged || attention.state === "done" ? "done" : finalResult ? "exited" : alive ? "running" : "exited";
+  return {
+    runId: worker.runId,
+    worker: worker.name,
+    pid: worker.pid,
+    alive,
+    status: workerStatusLabel,
+    attention,
+    branch: worker.branch,
+    worktreePath: worker.worktreePath,
+    ownedPaths: worker.ownedPaths,
+    stdoutBytes,
+    stderrBytes,
+    heartbeatBytes,
+    firstEventAt: parsed.firstEventAt,
+    lastEventAt: parsed.lastEventAt,
+    lastActivityAt,
+    currentTool: completionAcknowledged ? null : parsed.currentTool,
+    heartbeatCount: heartbeat.heartbeatCount,
+    lastHeartbeatAt: heartbeat.lastHeartbeatAt,
+    lastHeartbeatPhase: heartbeat.lastHeartbeatPhase,
+    lastHeartbeatSummary: heartbeat.lastHeartbeatSummary,
+    heartbeatBlocker: heartbeat.heartbeatBlocker,
+    timestampAnomalies: heartbeat.timestampAnomalies,
+    finalResult,
+    error,
+    changedFiles,
+    gitAncestry,
+    instructionPolicyFingerprint: worker.instructionPolicyFingerprint ?? null,
+    instructionPolicyEvidence: worker.instructionPolicyEvidence ?? null
+  };
+}
+function isFinishedWorkerStatus(status) {
+  if (status.finalResult) return true;
+  if (status.alive === false) return true;
+  if (status.status === "exited" || status.status === "done") return true;
+  return false;
+}
+function isLandingBlockedWorkerStatus(status) {
+  if (!status.finalResult) return false;
+  return status.attention.state === "needs_attention" || status.attention.state === "blocked";
+}
+
+// src/harness-lease-owner.ts
+var HARNESS_LEASE_PREFIX = "kynver-harness:";
+var RUNNER_MARKER = "@runner:";
+function trimOrNull4(value) {
+  if (!value?.trim()) return null;
+  return value.trim();
+}
+function parseHarnessLeaseRunId(leaseOwner) {
+  const owner = trimOrNull4(leaseOwner);
+  if (!owner?.startsWith(HARNESS_LEASE_PREFIX)) return null;
+  const body = owner.slice(HARNESS_LEASE_PREFIX.length);
+  const atRunner = body.indexOf(RUNNER_MARKER);
+  if (atRunner >= 0) return body.slice(0, atRunner).trim() || null;
+  return body.trim() || null;
+}
+function harnessLeaseOwnerMatchesRun(leaseOwner, runId) {
+  const expectedRun = trimOrNull4(runId);
+  if (!expectedRun) return false;
+  return parseHarnessLeaseRunId(leaseOwner) === expectedRun;
+}
+
+// src/monitor/monitor.classify.ts
+function classifyWorkerHealth(input) {
+  const { worker, status, taskLease } = input;
+  const leaseOwner = taskLease?.leaseOwner ?? null;
+  if (worker.dispatched && taskLease) {
+    if (taskLease.status === "running" && leaseOwner && !harnessLeaseOwnerMatchesRun(leaseOwner, worker.runId)) {
+      return {
+        health: "orphaned",
+        reason: `task lease held by ${leaseOwner}, expected harness run ${worker.runId}`
+      };
+    }
+    if (taskLease.status === "running" && !status.alive && !status.finalResult) {
+      return {
+        health: "orphaned",
+        reason: "board task running but worker process is not alive"
+      };
+    }
+  }
+  if (worker.status === "running" && !status.alive && !status.finalResult) {
+    return {
+      health: "orphaned",
+      reason: "worker.json still running but process is dead"
+    };
+  }
+  if (status.attention.state === "stale") {
+    return { health: "stale", reason: status.attention.reason };
+  }
+  const hbMs = status.lastHeartbeatAt ? Date.parse(status.lastHeartbeatAt) : NaN;
+  if (status.alive && Number.isFinite(hbMs) && Date.now() - hbMs > STALE_MS) {
+    return {
+      health: "stale",
+      reason: `heartbeat older than ${Math.floor(STALE_MS / 1e3)}s`
+    };
+  }
+  if (status.alive && worker.pid && !isPidAlive(worker.pid)) {
+    return { health: "orphaned", reason: "pid recorded but process is not alive" };
+  }
+  if (taskLease?.status === "running" && !status.alive && status.finalResult) {
+    return {
+      health: "healthy",
+      reason: "finished worker awaiting completion replay"
+    };
+  }
+  return {
+    health: "healthy",
+    reason: status.attention.reason || "worker within expected lifecycle bounds"
+  };
+}
+
+// src/paths.ts
+import { homedir as homedir2 } from "node:os";
+import path2 from "node:path";
+
+// src/config.ts
+import { homedir, totalmem } from "node:os";
+import path from "node:path";
+
+// src/wsl-host.ts
+var DEFAULT_WSL_HOST_WARN_FREE_BYTES = 25 * 1024 * 1024 * 1024;
+var DEFAULT_WSL_HOST_CRITICAL_FREE_BYTES = 12 * 1024 * 1024 * 1024;
+
+// src/disk-gate.ts
+var DEFAULT_WARN_FREE_BYTES = 30 * 1024 * 1024 * 1024;
+var DEFAULT_CRITICAL_FREE_BYTES = 15 * 1024 * 1024 * 1024;
+
+// src/resource-gate.ts
+var DEFAULT_PER_WORKER_MEM_BYTES = 500 * 1024 * 1024;
+var DEFAULT_MEM_RESERVE_BYTES = 4 * 1024 * 1024 * 1024;
+
+// src/config.ts
+var CONFIG_DIR = path.join(homedir(), ".kynver");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+var CREDENTIALS_FILE = path.join(CONFIG_DIR, "credentials");
+var SETUP_PER_WORKER_MEM_BYTES = 500 * 1024 * 1024;
+var SETUP_MEM_RESERVE_BYTES = 4 * 1024 * 1024 * 1024;
+
+// src/paths.ts
+var LEGACY_ROOT = path2.join(homedir2(), ".openclaw", "harness");
+
+// src/completion-ack.ts
+function hasCompletionAck(worker) {
+  return Boolean(worker.completionReportedAt?.trim());
+}
+
+// src/monitor/monitor.terminal.ts
+function assessAutoCompleteEligibility(input) {
+  const { worker, status } = input;
+  const blockers = [];
+  if (worker.localOnly) {
+    blockers.push("local-only worker (no board linkage)");
+  }
+  if (!worker.agentOsId || !worker.taskId) {
+    blockers.push("missing agentOsId/taskId linkage");
+  }
+  if (hasCompletionAck(worker)) {
+    blockers.push("completion already acknowledged");
+  }
+  if (worker.completionBlocker) {
+    blockers.push(worker.completionBlocker);
+  }
+  if (status.heartbeatBlocker && status.alive) {
+    blockers.push(`worker heartbeat blocker: ${status.heartbeatBlocker}`);
+  }
+  if (status.attention.state === "blocked") {
+    blockers.push(status.attention.reason || "worker attention blocked");
+  }
+  if (isLandingBlockedWorkerStatus(status)) {
+    blockers.push(status.attention.reason || "landing gate blocked");
+  }
+  const terminalVerified = isFinishedWorkerStatus(status);
+  let terminalReason;
+  if (terminalVerified) {
+    if (status.finalResult) terminalReason = "final_result";
+    else if (!status.alive) terminalReason = "process_exited";
+    else terminalReason = "terminal_status";
+  } else {
+    blockers.push("worker has not reached a terminal condition");
+  }
+  const eligible = terminalVerified && blockers.length === 0;
+  return {
+    eligible,
+    terminalVerified,
+    terminalReason,
+    blockers
+  };
+}
+export {
+  assessAutoCompleteEligibility,
+  classifyWorkerHealth,
+  computeWorkerStatus
+};
+//# sourceMappingURL=monitor.js.map