@kynver-app/runtime 0.1.42 → 0.1.48

package/dist/index.js

@@ -508,12 +508,12 @@ var DEFAULT_CRITICAL_FREE_BYTES = 15 * 1024 * 1024 * 1024;
 var DEFAULT_MAX_USED_PERCENT = 80;
 var DEFAULT_HARD_MAX_USED_PERCENT = 90;
 function observeRunnerDiskGate(input = {}) {
-  const path35 = input.diskPath?.trim() || "/";
+  const path38 = input.diskPath?.trim() || "/";
   const warnBelowBytes = input.diskFreeWarnBytes ?? DEFAULT_WARN_FREE_BYTES;
   const criticalBelowBytes = input.diskFreeCriticalBytes ?? DEFAULT_CRITICAL_FREE_BYTES;
   const maxUsedPercent = input.diskMaxUsedPercent ?? DEFAULT_MAX_USED_PERCENT;
   const hardMaxUsedPercent = input.diskHardMaxUsedPercent ?? DEFAULT_HARD_MAX_USED_PERCENT;
-  const stats = statfsSync(path35);
+  const stats = statfsSync(path38);
   const freeBytes = Number(stats.bavail) * Number(stats.bsize);
   const totalBytes = Number(stats.blocks) * Number(stats.bsize);
   const usedPercent = totalBytes > 0 ? (totalBytes - freeBytes) / totalBytes * 100 : 100;
@@ -533,7 +533,7 @@ function observeRunnerDiskGate(input = {}) {
   }
   return {
     ok,
-    path: path35,
+    path: path38,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -546,8 +546,29 @@ function observeRunnerDiskGate(input = {}) {
 }
 
 // src/resource-gate.ts
-import { readFileSync as readFileSync6 } from "node:fs";
+import os2 from "node:os";
+
+// src/bounded-build/meminfo.ts
+import { readFileSync as readFileSync4 } from "node:fs";
 import os from "node:os";
+function readMemAvailableBytes(meminfoText) {
+  if (meminfoText !== void 0) {
+    const match = meminfoText.match(/^MemAvailable:\s+(\d+)\s*kB/m);
+    if (match) return Number(match[1]) * 1024;
+    return os.freemem();
+  }
+  if (process.platform === "linux") {
+    try {
+      const meminfo = readFileSync4("/proc/meminfo", "utf8");
+      const match = meminfo.match(/^MemAvailable:\s+(\d+)\s*kB/m);
+      if (match) return Number(match[1]) * 1024;
+    } catch {
+    }
+  }
+  return os.freemem();
+}
+
+// src/resource-gate.ts
 import path6 from "node:path";
 
 // src/run-store.ts
@@ -623,7 +644,7 @@ function runDirectory(id) {
 }
 
 // src/heartbeat.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "node:fs";
 var HEARTBEAT_FUTURE_SKEW_MS = 6e4;
 function isTerminalHeartbeatPhase(phase) {
   return phase === "complete";
@@ -645,7 +666,7 @@ function parseHeartbeat(file) {
   if (!existsSync6(file)) return result;
   const maxFutureMs = Date.now() + HEARTBEAT_FUTURE_SKEW_MS;
   const clampedTo = new Date(maxFutureMs).toISOString();
-  const lines = readFileSync4(file, "utf8").split("\n").filter(Boolean);
+  const lines = readFileSync5(file, "utf8").split("\n").filter(Boolean);
   for (const line of lines) {
     const entry = safeJson(line);
     if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
@@ -672,7 +693,155 @@ function parseHeartbeat(file) {
 }
 
 // src/stream.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
+
+// src/shell-command-outcome.ts
+var NPM_AUDIT_RE = /\bnpm\s+audit\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 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 (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);
@@ -693,16 +862,43 @@ function recordStreamResult(result, event) {
     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") return;
+  parsed.lastShellOutcome = outcome;
+}
 function parseHarnessStream(file) {
   const result = {
     firstEventAt: null,
     lastEventAt: null,
     currentTool: null,
     finalResult: null,
-    error: null
+    error: null,
+    lastShellOutcome: null
   };
   if (!existsSync7(file)) return result;
-  const lines = readFileSync5(file, "utf8").split("\n").filter(Boolean);
+  const lines = readFileSync6(file, "utf8").split("\n").filter(Boolean);
   for (const line of lines) {
     const event = safeJson(line);
     if (!event) continue;
@@ -727,6 +923,19 @@ function parseHarnessStream(file) {
       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);
     }
@@ -736,6 +945,25 @@ function parseHarnessStream(file) {
 function parseClaudeStream(file) {
   return parseHarnessStream(file);
 }
+function summarizeShellToolCallEvent(event) {
+  const shell = shellPayloadFromCursorEvent(event);
+  if (!shell) return void 0;
+  const outcome = classifyShellCommandOutcome({
+    command: shell.command,
+    exitCode: shell.exitCode,
+    stdout: shell.stdout,
+    stderr: shell.stderr,
+    interleavedOutput: shell.interleaved
+  });
+  const cmd = oneLine(shell.command).slice(0, 120);
+  if (outcome.kind === "audit_findings") {
+    return `[audit:findings] ${outcome.summary}${cmd ? ` \xB7 ${cmd}` : ""}`;
+  }
+  if (outcome.kind === "command_failure") {
+    return `[command:failed] ${outcome.summary}${cmd ? ` \xB7 ${cmd}` : ""}`;
+  }
+  return `[command:ok] exit 0${cmd ? ` \xB7 ${cmd}` : ""}`;
+}
 function summarizeEvent(event) {
   if (event.type === "system" && event.subtype) {
     return `[system:${event.subtype}] ${String(event.status || event.cwd || "")}`.trim();
@@ -768,6 +996,8 @@ function summarizeEvent(event) {
   }
   if (event.type === "tool_call") {
     const subtype = String(event.subtype || "");
+    const shellSummary = subtype === "completed" ? summarizeShellToolCallEvent(event) : void 0;
+    if (shellSummary) return shellSummary;
     const toolCall = event.tool_call && typeof event.tool_call === "object" && !Array.isArray(event.tool_call) ? event.tool_call : void 0;
     const name = cursorToolNameFromCall(toolCall) ?? "tool";
     return `[tool:${subtype}] ${name}`;
@@ -809,7 +1039,7 @@ var FAILURE_PATTERNS = [
     label: "provider authentication failed"
   }
 ];
-function tidy(errorText, max = 240) {
+function tidy2(errorText, max = 240) {
   const oneLine2 = errorText.replace(/\s+/g, " ").trim();
   return oneLine2.length > max ? `${oneLine2.slice(0, max - 1)}\u2026` : oneLine2;
 }
@@ -818,7 +1048,7 @@ function classifyExitFailure(errorText) {
   if (!text) return null;
   for (const pattern of FAILURE_PATTERNS) {
     if (pattern.test.test(text)) {
-      return { blocked: true, reason: `${pattern.label}: ${tidy(text)}` };
+      return { blocked: true, reason: `${pattern.label}: ${tidy2(text)}` };
     }
   }
   return null;
@@ -884,6 +1114,63 @@ function assessExitedWorkerSalvage(input) {
 
 // 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",
+  "REDIS_URL",
+  "GOOGLE_CLIENT_SECRET",
+  "GITHUB_CLIENT_SECRET",
+  "KYNVER_API_KEY",
+  "KYNVER_SERVICE_SECRET",
+  "KYNVER_RUNTIME_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);
+var FORBIDDEN_SUFFIXES = ["_SECRET", "_API_KEY"];
+function isForbiddenWorkerEnvKey(key) {
+  if (FORBIDDEN_KEY_SET.has(key)) return true;
+  return FORBIDDEN_SUFFIXES.some((suffix) => key.endsWith(suffix));
+}
+function listForbiddenWorkerEnvKeys(env) {
+  return Object.keys(env).filter(isForbiddenWorkerEnvKey).sort();
+}
+function scrubWorkerEnv(env) {
+  const next = { ...env };
+  for (const key of Object.keys(next)) {
+    if (isForbiddenWorkerEnvKey(key)) delete next[key];
+  }
+  return next;
+}
+function auditWorkerEnv(env) {
+  const forbiddenPresent = listForbiddenWorkerEnvKeys(env);
+  return { forbiddenPresent, safe: forbiddenPresent.length === 0 };
+}
+function scrubClaudeEnv(env) {
+  return scrubWorkerEnv(env);
+}
+
+// src/git.ts
 function git(cwd, args, options = {}) {
   const res = spawnSync("git", args, { cwd, encoding: "utf8" });
   if (res.status !== 0 && !options.allowFailure) {
@@ -999,11 +1286,6 @@ function unknownAncestry(base, error, head = null) {
     error
   };
 }
-function scrubClaudeEnv(env) {
-  const next = { ...env };
-  delete next.ANTHROPIC_API_KEY;
-  return next;
-}
 
 // src/landing-gate.ts
 function trimOrNull2(value) {
@@ -1353,15 +1635,7 @@ function computeAutoMaxWorkers(totalMemBytes, opts = {}) {
   return Math.min(raw, AUTO_MAX_WORKERS_CEILING);
 }
 function readAvailableMemBytes() {
-  if (process.platform === "linux") {
-    try {
-      const meminfo = readFileSync6("/proc/meminfo", "utf8");
-      const match = meminfo.match(/^MemAvailable:\s+(\d+)\s*kB/m);
-      if (match) return Number(match[1]) * 1024;
-    } catch {
-    }
-  }
-  return os.freemem();
+  return readMemAvailableBytes();
 }
 function isActiveHarnessWorker(worker) {
   const status = computeWorkerStatus(worker);
@@ -1389,7 +1663,7 @@ function observeRunnerResourceGate(input) {
     input.config,
     input.configuredMaxWorkersOverride
   );
-  const totalMemBytes = input.totalMemBytes ?? os.totalmem();
+  const totalMemBytes = input.totalMemBytes ?? os2.totalmem();
   const freeMemBytes = input.freeMemBytes ?? readAvailableMemBytes();
   const activeWorkers = input.activeWorkers ?? countActiveWorkersGlobal();
   const budgetBytes = Math.max(0, Math.floor(totalMemBytes * memUtilization) - memReserveBytes);
@@ -1598,7 +1872,7 @@ var claudeProvider = {
         cwd: opts.worktreePath,
         detached: true,
         stdio,
-        env: scrubClaudeEnv(process.env)
+        env: scrubWorkerEnv(process.env)
       })
     );
     closeSync(stdoutFd);
@@ -1875,6 +2149,7 @@ function buildPrompt(input) {
     "Structured final result (recommended): record completion as JSON with summary, laneExpertise { whatChanged, why, files, prUrls, verification, risks, blockers, lessonsLearned, laneGuidance }, and targetPrReconciliation [{ prUrl, outcome: merged|skipped|blocked, mergeCommit?, reason? }] for every target PR on landing-only tasks.",
     "Completion handoff (required): before you stop, ensure the harness records a final result \u2014 summarize outcome in your last message and append a heartbeat line with phase `complete`. If you leave uncommitted changes or committed work without a PR, the orchestrator blocks completion until a GitHub PR exists (or you discard/commit cleanly). Exiting with only dirty files and no PR routes to salvage review, not production review.",
     "PR-ready handoff: for substantial implementation work, commit, push, and open a GitHub PR (draft OK) on your branch before finishing \u2014 or rely on the harness to run `gh pr create` at completion when `gh` is authenticated.",
+    "Expert review / production-review workers (Dalton/Lorentz, plan-review-task, scheduledJob reviewer children): do NOT open new implementation PRs \u2014 review the parent task's existing PR and record reviewVerdict in finalResult; landing-contract targetPrReconciliation does not apply.",
     "Worker resource guard: do not run full monorepo verification (`npm run typecheck`, `npm run build`, or equivalent) from this worker lane unless an operator explicitly requests it. Use targeted checks for touched paths and rely on CI/operator lanes for heavy gates.",
     "npm publish boundary: do not run `npm publish`, do not republish `@kynver-app/*` packages, and do not block on an operator to publish. When you need newer runtime code than npm, use this repo checkout (`npm run kynver:build`, `npm run kynver`) and record evidence: packages/kynver-runtime/package.json version + git ref in your completion report.",
     "If verification fails (including OOM), append a heartbeat line immediately with the last command, failure reason, dirty-file status, commit/PR handoff state, and next action so recovery does not require log spelunking.",
@@ -1985,12 +2260,12 @@ function resolveAgentBin() {
   return "agent";
 }
 function cursorWorkerEnv(agentBin, spawnTarget) {
-  return {
+  return scrubWorkerEnv({
     ...process.env,
     CI: "1",
     NO_COLOR: "1",
     ...spawnTarget.bundledVersionDir ? { CURSOR_INVOKED_AS: path9.basename(agentBin) || "agent.cmd" } : {}
-  };
+  });
 }
 var cursorProvider = {
   name: "cursor",
@@ -2083,6 +2358,65 @@ function persistCompletionAck(worker, runId, fields) {
 // src/worker-ops.ts
 import path11 from "node:path";
 
+// src/completion-response.ts
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function asString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length ? trimmed : null;
+}
+var ADVANCED_OUTCOMES = /* @__PURE__ */ new Set([
+  "review_scheduled",
+  "review_already_scheduled"
+]);
+function summarizeHarnessCompletionResponse(parsed) {
+  const record = asRecord(parsed);
+  if (!record) {
+    return { routeOutcome: null, taskAdvanced: false, detail: null };
+  }
+  const outcome = asString(record.outcome);
+  const detail = asString(record.detail) ?? asString(record.error);
+  const task = asRecord(record.task);
+  const taskStatus = task ? asString(task.status) : null;
+  const taskAdvanced = outcome !== null && ADVANCED_OUTCOMES.has(outcome) || taskStatus === "awaiting_review" || taskStatus === "done";
+  return {
+    routeOutcome: outcome,
+    taskAdvanced,
+    detail
+  };
+}
+function completionPostSucceeded(summary) {
+  return summary.taskAdvanced;
+}
+
+// src/harness-expert-review.ts
+var EXPERT_LANE_REVIEW_REF = "expert-lane-pr-review:";
+var PLAN_REVIEW_EXECUTOR_REF = "plan-review-task";
+var SCHEDULED_JOB_EXECUTOR_REF = "scheduledjob:";
+function normalizePersonaSlug(value) {
+  if (!value) return null;
+  const t = value.trim().toLowerCase();
+  return t.length ? t : null;
+}
+function isHarnessExpertReviewWorker(worker) {
+  const ref = (worker.executorRef ?? "").toLowerCase();
+  if (ref.startsWith(EXPERT_LANE_REVIEW_REF)) return true;
+  if (ref === PLAN_REVIEW_EXECUTOR_REF || ref.startsWith("daemon-review:")) return true;
+  if (ref.startsWith(SCHEDULED_JOB_EXECUTOR_REF) && worker.parentTaskId) {
+    const persona = normalizePersonaSlug(worker.personaSlug);
+    if (persona === "lorentz" || persona === "dalton") return true;
+  }
+  const title = (worker.title ?? "").toLowerCase();
+  if (title.includes("expert pr review")) return true;
+  if (worker.parentTaskId && (title.startsWith("review:") || title.includes("review required") || title.includes("runtime review"))) {
+    const persona = normalizePersonaSlug(worker.personaSlug);
+    if (persona === "lorentz" || persona === "dalton") return true;
+  }
+  return false;
+}
+
 // src/pr-handoff/pr-handoff-assess.ts
 var REVIEW_LANE_RULE = /^(lane:)?(review|deep_review|planning|landing)(:|$)/i;
 function trimOrNull4(value) {
@@ -2113,6 +2447,14 @@ function assessPrHandoffRequirement(input) {
   if (!input.dispatched) {
     return { required: false, reason: "not_dispatched" };
   }
+  if (isHarnessExpertReviewWorker({
+    title: input.taskTitle ?? void 0,
+    personaSlug: input.personaSlug,
+    parentTaskId: input.parentTaskId,
+    executorRef: input.executorRef
+  })) {
+    return { required: false, reason: "expert_review_task" };
+  }
   const rule = trimOrNull4(input.routingRule) ?? "";
   if (rule && REVIEW_LANE_RULE.test(rule)) {
     return { required: false, reason: "review_lane" };
@@ -2120,7 +2462,7 @@ function assessPrHandoffRequirement(input) {
   if (trimOrNull4(input.patchPath) || trimOrNull4(input.artifactBundlePath)) {
     return { required: false, reason: "patch_or_bundle" };
   }
-  const prUrl = trimOrNull4(input.prUrl) ?? trimOrNull4(input.snapshot.prUrl);
+  const prUrl = trimOrNull4(input.prUrl) ?? trimOrNull4(input.taskPrUrl) ?? trimOrNull4(input.snapshot.prUrl);
   if (prUrl) {
     return { required: false, reason: "already_has_pr" };
   }
@@ -2143,6 +2485,36 @@ function buildPrHandoffSnapshotFromStatus(status, extras) {
 
 // src/pr-handoff/pr-handoff-gh.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
+
+// src/github-repo.ts
+function parseGithubOwnerRepo(remoteUrl) {
+  const trimmed = remoteUrl.trim();
+  if (!trimmed) return null;
+  const ssh = trimmed.match(/^git@github\.com:([^/]+\/[^/\s]+?)(?:\.git)?$/i);
+  if (ssh) return normalizeOwnerRepo(ssh[1]);
+  const scp = trimmed.match(/^ssh:\/\/git@github\.com\/([^/]+\/[^/\s]+?)(?:\.git)?$/i);
+  if (scp) return normalizeOwnerRepo(scp[1]);
+  try {
+    const url = new URL(trimmed.includes("://") ? trimmed : `https://${trimmed}`);
+    if (url.hostname.toLowerCase() !== "github.com") return null;
+    const parts = url.pathname.replace(/^\/+|\/+$/g, "").split("/");
+    if (parts.length < 2) return null;
+    const [owner, repo] = parts;
+    if (!owner || !repo) return null;
+    return `${owner}/${repo.replace(/\.git$/i, "")}`;
+  } catch {
+    return null;
+  }
+}
+function normalizeOwnerRepo(value) {
+  const parts = value.split("/").filter(Boolean);
+  if (parts.length < 2) return null;
+  const owner = parts[0];
+  const repo = parts[1].replace(/\.git$/i, "");
+  return owner && repo ? `${owner}/${repo}` : null;
+}
+
+// src/pr-handoff/pr-handoff-gh.ts
 function capture(bin, cwd, args) {
   try {
     const res = spawnSync2(bin, args, { cwd, encoding: "utf8" });
@@ -2165,21 +2537,13 @@ var defaultPrHandoffExec = {
   git: (cwd, args) => gitCapture(cwd, args),
   gh: (cwd, args) => capture("gh", cwd, args)
 };
-function parseGithubRepo(remoteUrl) {
-  const trimmed = remoteUrl.trim();
-  const ssh = trimmed.match(/git@github\.com:([^/]+\/[^/.]+)(?:\.git)?/i);
-  if (ssh) return ssh[1];
-  const https = trimmed.match(/github\.com[/:]([^/]+\/[^/.]+?)(?:\.git)?/i);
-  if (https) return https[1];
-  return null;
-}
 function firstLine(text) {
   return text.split("\n").map((l) => l.trim()).find(Boolean) ?? "";
 }
 function resolveGithubRepo(worktreePath, exec) {
   const remote = exec.git(worktreePath, ["remote", "get-url", "origin"]);
   if (remote.status !== 0) return null;
-  return parseGithubRepo(remote.stdout);
+  return parseGithubOwnerRepo(remote.stdout);
 }
 function resolveHeadCommit(worktreePath, exec) {
   const head = exec.git(worktreePath, ["rev-parse", "HEAD"]);
@@ -2315,6 +2679,11 @@ function ensurePrReadyHandoff(input, exec = defaultPrHandoffExec) {
     dispatched: input.worker.dispatched,
     routingRule: input.worker.routingRule,
     prUrl: prUrlHint,
+    taskTitle: input.worker.taskTitle,
+    executorRef: input.worker.executorRef,
+    parentTaskId: input.worker.parentTaskId,
+    personaSlug: input.worker.personaSlug,
+    taskPrUrl: input.worker.taskPrUrl,
     snapshot
   });
   if (!requirement.required) {
@@ -2513,10 +2882,10 @@ function completionErrorText(parsed) {
   }
   return void 0;
 }
-function asRecord(value) {
+function asRecord2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-function asString(value) {
+function asString2(value) {
   if (typeof value !== "string") return null;
   const trimmed = value.trim();
   return trimmed.length ? trimmed : null;
@@ -2636,7 +3005,27 @@ async function tryCompleteWorker(args) {
     }
   }
   if (result.ok) {
+    const summary = summarizeHarnessCompletionResponse(result.parsed);
+    if (!completionPostSucceeded(summary)) {
+      const detail2 = summary.detail ?? (summary.routeOutcome ? `harness completion returned ${summary.routeOutcome}` : "harness completion did not advance the linked task");
+      const reason2 = `completion acknowledged but board not advanced: ${detail2}`;
+      persistCompletionBlocker(worker, reason2);
+      const ack2 = {
+        completionReportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        completionOutcome: "rejected",
+        completionResponse: result.parsed
+      };
+      persistCompletionAck(worker, worker.runId, ack2);
+      return {
+        ok: false,
+        httpStatus: result.status,
+        response: result.parsed,
+        reason: reason2,
+        completionBlocked: true
+      };
+    }
     persistCompletionBlocker(worker, void 0);
+    const routeOutcome = summary.routeOutcome ?? "acknowledged";
     const ack = {
       completionReportedAt: (/* @__PURE__ */ new Date()).toISOString(),
       completionOutcome: "acknowledged",
@@ -2649,6 +3038,7 @@ async function tryCompleteWorker(args) {
       ok: true,
       httpStatus: result.status,
       response: result.parsed,
+      reason: routeOutcome,
       ...prUrl ? { prHandoff: { prUrl } } : {}
     };
   }
@@ -2741,13 +3131,13 @@ function buildRunBoard(runId) {
     const completionBlocker = typeof rawBlocker === "string" && rawBlocker ? rawBlocker : void 0;
     const boardStatus = completionBlocker ? "blocked" : status.status;
     const boardAttention = completionBlocker ? "blocked" : status.attention.state;
-    const completionResponse = asRecord(worker.completionResponse);
-    const completionTask = asRecord(completionResponse?.task);
-    const completionOutcome = asString(completionResponse?.outcome);
-    const completionRouteStatus = asString(completionResponse?.status);
+    const completionResponse = asRecord2(worker.completionResponse);
+    const completionTask = asRecord2(completionResponse?.task);
+    const completionOutcome = asString2(completionResponse?.outcome);
+    const completionRouteStatus = asString2(completionResponse?.status);
     const completionWarnings = Array.isArray(completionResponse?.warnings) ? completionResponse.warnings.filter((w) => typeof w === "string" && w.trim().length > 0) : [];
-    const prUrl = asString(completionTask?.prUrl) ?? asString(completionResponse?.prUrl);
-    const completionReportedAt = asString(worker.completionReportedAt);
+    const prUrl = asString2(completionTask?.prUrl) ?? asString2(completionResponse?.prUrl);
+    const completionReportedAt = asString2(worker.completionReportedAt);
     const lifecycleStage = deriveLifecycleStage({
       finished: isFinishedWorkerStatus(status),
       completionBlocker,
@@ -3173,6 +3563,10 @@ function spawnWorkerProcess(run, opts) {
     ...!opts.agentOsId || !opts.taskId ? { localOnly: true } : {},
     routingRule: routing.rule,
     ...routing.requestedModel ? { requestedModel: routing.requestedModel } : {},
+    ...opts.executorRef ? { executorRef: String(opts.executorRef) } : {},
+    ...opts.parentTaskId ? { parentTaskId: String(opts.parentTaskId) } : {},
+    ...opts.taskTitle ? { taskTitle: String(opts.taskTitle) } : {},
+    ...opts.taskPrUrl ? { taskPrUrl: String(opts.taskPrUrl) } : {},
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   saveWorker(run.id, worker);
@@ -3867,7 +4261,7 @@ function readHarnessWorkerContext(decision) {
     personaInjectionReady
   };
 }
-function normalizePersonaSlug(value) {
+function normalizePersonaSlug2(value) {
   if (typeof value !== "string") return null;
   const trimmed = value.trim().toLowerCase();
   return trimmed.length ? trimmed : null;
@@ -3938,7 +4332,8 @@ async function dispatchRun(args) {
       harnessBoardSnapshot: buildRunBoard(run.id),
       ...args.lane ? { lane: String(args.lane) } : {},
       executor: args.executor ? String(args.executor) : "harness",
-      ...args.diskPath ? { diskPath: String(args.diskPath) } : {}
+      ...args.diskPath ? { diskPath: String(args.diskPath) } : {},
+      ...args.targetTaskId ? { targetTaskId: String(args.targetTaskId) } : {}
     };
     const dispatch = await postJsonWithCredentialRefresh(dispatchUrl, secret, body, { agentOsId, baseUrl: base });
     const responseBody = dispatch.response;
@@ -3997,7 +4392,7 @@ async function dispatchRun(args) {
       const task = decision.task;
       const harnessContext = readHarnessWorkerContext(decision);
       const taskId = String(task.id);
-      const expectedPersona = normalizePersonaSlug(task.personaSlug);
+      const expectedPersona = normalizePersonaSlug2(task.personaSlug);
       if (expectedPersona && (!harnessContext?.personaInjectionReady || !harnessContext.personaMarkdown)) {
         outcomes.push({
           taskId,
@@ -4041,6 +4436,10 @@ async function dispatchRun(args) {
           agentOsId,
           taskId: String(task.id),
           planId,
+          executorRef: task.executorRef ? String(task.executorRef) : void 0,
+          parentTaskId: task.parentTaskId ? String(task.parentTaskId) : void 0,
+          taskTitle: task.title ? String(task.title) : void 0,
+          taskPrUrl: task.prUrl ? String(task.prUrl) : void 0,
           instructionPolicyMarkdown: harnessContext?.instructionPolicyMarkdown ?? null,
           instructionPolicyFingerprint: harnessContext?.instructionPolicyFingerprint ?? null,
           instructionPolicyEvidence: harnessContext?.instructionPolicyEvidence ?? null,
@@ -4117,6 +4516,13 @@ async function dispatchRun(args) {
   }
 }
 
+// src/fortress-engagement-gate.ts
+function isEngagementRequiredSkip(skip) {
+  if (skip.skipReason === "engagement_required") return true;
+  const reason = skip.reason ?? "";
+  return reason.includes("engagement_required") || reason.includes("engagement_not_found") || reason.includes("engagement_expired") || reason.includes("engagement_revoked");
+}
+
 // src/redact.ts
 function redactHarness(text, secret) {
   let out = text;
@@ -4262,7 +4668,7 @@ import { mkdirSync as mkdirSync7, realpathSync } from "node:fs";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // src/pipeline-tick.ts
-import path29 from "node:path";
+import path30 from "node:path";
 
 // src/pipeline-dispatch.ts
 var RESERVED_REVIEW_STARTS = 1;
@@ -4968,13 +5374,62 @@ function isPipelineCleanupEnabled() {
   return process.env.KYNVER_PIPELINE_CLEANUP !== "0";
 }
 
+// src/installed-package-versions.ts
+import { readFile } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import path29 from "node:path";
+var MANAGED_PACKAGES = [
+  "@kynver-app/runtime",
+  "@kynver-app/openclaw-agent-os",
+  "@kynver-app/mcp-agent-os"
+];
+function trim(value) {
+  const out = value?.trim();
+  return out ? out : null;
+}
+function unique(values) {
+  return [...new Set(values.filter((value) => Boolean(value)))];
+}
+function moduleRoots() {
+  const home = homedir5();
+  const openClawPrefix = trim(process.env.KYNVER_OPENCLAW_NPM_ROOT) ?? trim(process.env.OPENCLAW_NPM_ROOT) ?? path29.join(home, ".openclaw", "npm");
+  const npmGlobalRoot = trim(process.env.KYNVER_NPM_GLOBAL_ROOT) ?? trim(process.env.KYNVER_NPM_GLOBAL_MODULES_ROOT) ?? (trim(process.env.NPM_CONFIG_PREFIX) ? path29.join(trim(process.env.NPM_CONFIG_PREFIX), "lib", "node_modules") : path29.join(home, ".npm-global", "lib", "node_modules"));
+  return unique([
+    path29.join(openClawPrefix, "lib", "node_modules"),
+    path29.join(openClawPrefix, "node_modules"),
+    npmGlobalRoot.endsWith("node_modules") ? npmGlobalRoot : path29.join(npmGlobalRoot, "lib", "node_modules")
+  ]);
+}
+async function readVersion(packageJsonPath) {
+  try {
+    const parsed = JSON.parse(await readFile(packageJsonPath, "utf8"));
+    return typeof parsed.version === "string" && parsed.version.trim() ? parsed.version.trim() : null;
+  } catch {
+    return null;
+  }
+}
+async function collectInstalledPackageVersions(observedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  const roots = moduleRoots();
+  const out = {};
+  for (const packageName of MANAGED_PACKAGES) {
+    for (const root of roots) {
+      const packageJsonPath = path29.join(root, packageName, "package.json");
+      const version = await readVersion(packageJsonPath);
+      if (!version) continue;
+      out[packageName] = { version, observedAt, path: packageJsonPath };
+      break;
+    }
+  }
+  return out;
+}
+
 // src/pipeline-tick.ts
 async function completeFinishedWorkers(runId, args) {
   const run = loadRun(runId);
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path29.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path30.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.taskId || worker.localOnly) continue;
@@ -5005,12 +5460,14 @@ async function postOperatorTick(agentOsId, runId, resourceGate, args) {
   const base = resolveBaseUrl(args.baseUrl ? String(args.baseUrl) : void 0);
   const secret = await resolveCallbackSecretWithMint(args.secret ? String(args.secret) : void 0, agentOsId, { baseUrl: base });
   const url = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/operator/tick`;
+  const packageVersions = await collectInstalledPackageVersions();
   const res = await postJson(url, secret, {
     agentOsId,
     runId,
     ingestHarness: true,
     harnessBoardSnapshot: buildRunBoard(runId),
-    resourceGate
+    resourceGate,
+    packageVersions
   });
   return { ok: res.ok, httpStatus: res.status, response: res.response };
 }
@@ -5113,6 +5570,231 @@ async function runDaemon(args) {
   console.error(JSON.stringify({ event: "daemon_stop", runId, agentOsId }));
 }
 
+// src/plan-progress.ts
+import path31 from "node:path";
+
+// src/bounded-build/constants.ts
+var DEFAULT_BUILD_MEM_BUDGET_BYTES = 1536 * 1024 * 1024;
+var DEFAULT_BUILD_MEM_RESERVE_BYTES = 2 * 1024 * 1024 * 1024;
+var DEFAULT_NODE_OLD_SPACE_SIZE_MB = 1024;
+var DEFAULT_SYSTEMD_MEMORY_MAX = "1.5G";
+var DEFAULT_SYSTEMD_MEMORY_SWAP_MAX = "2G";
+
+// src/bounded-build/node-options.ts
+var MAX_OLD_SPACE_RE = /--max-old-space-size=(\d+)/;
+function parsePositiveInt(value, fallback) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return fallback;
+  return Math.floor(n);
+}
+function resolveNodeOldSpaceSizeMb() {
+  return parsePositiveInt(process.env.KYNVER_NODE_OLD_SPACE_SIZE_MB, DEFAULT_NODE_OLD_SPACE_SIZE_MB);
+}
+function mergeNodeOptionsForBuildCheck(baseEnv = process.env) {
+  const env = { ...baseEnv };
+  if (process.env.KYNVER_NODE_OLD_SPACE_SIZE_MB === "0") {
+    return env;
+  }
+  const existing = env.NODE_OPTIONS ?? "";
+  if (MAX_OLD_SPACE_RE.test(existing)) {
+    return env;
+  }
+  const mb = resolveNodeOldSpaceSizeMb();
+  const flag = `--max-old-space-size=${mb}`;
+  env.NODE_OPTIONS = existing.trim() ? `${existing.trim()} ${flag}` : flag;
+  return env;
+}
+function formatNodeOptionsFlag(mb = resolveNodeOldSpaceSizeMb()) {
+  return `--max-old-space-size=${mb}`;
+}
+
+// src/bounded-build/systemd-wrap.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+var systemdAvailableCache;
+function isSystemdRunAvailable() {
+  if (process.env.KYNVER_BUILD_SKIP_SYSTEMD === "1" || process.env.KYNVER_BUILD_SKIP_SYSTEMD === "true") {
+    return false;
+  }
+  if (systemdAvailableCache !== void 0) return systemdAvailableCache;
+  if (process.platform !== "linux") {
+    systemdAvailableCache = false;
+    return false;
+  }
+  const res = spawnSync3("systemd-run", ["--version"], { encoding: "utf8", stdio: ["ignore", "ignore", "pipe"] });
+  systemdAvailableCache = res.status === 0;
+  return systemdAvailableCache;
+}
+function buildSystemdRunArgv(opts) {
+  const memoryMax = opts.memoryMax ?? process.env.KYNVER_BUILD_SYSTEMD_MEMORY_MAX ?? DEFAULT_SYSTEMD_MEMORY_MAX;
+  const memorySwapMax = opts.memorySwapMax ?? process.env.KYNVER_BUILD_SYSTEMD_MEMORY_SWAP_MAX ?? DEFAULT_SYSTEMD_MEMORY_SWAP_MAX;
+  const argv = [
+    "systemd-run",
+    "--scope",
+    "--collect",
+    "-p",
+    `MemoryMax=${memoryMax}`,
+    "-p",
+    `MemorySwapMax=${memorySwapMax}`
+  ];
+  if (opts.cwd) {
+    argv.push("--working-directory", opts.cwd);
+  }
+  argv.push("--", ...opts.command);
+  return argv;
+}
+
+// src/bounded-build/admission.ts
+import { spawnSync as spawnSync4 } from "node:child_process";
+function positiveInt3(value, fallback) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return fallback;
+  return Math.floor(n);
+}
+function resolveBuildAdmissionConfig(config = loadUserConfig()) {
+  const envBudget = process.env.KYNVER_BUILD_MEM_BUDGET_BYTES ? positiveInt3(process.env.KYNVER_BUILD_MEM_BUDGET_BYTES, DEFAULT_BUILD_MEM_BUDGET_BYTES) : void 0;
+  const envReserve = process.env.KYNVER_BUILD_MEM_RESERVE_BYTES ? positiveInt3(process.env.KYNVER_BUILD_MEM_RESERVE_BYTES, DEFAULT_BUILD_MEM_RESERVE_BYTES) : void 0;
+  return {
+    perBuildBudgetBytes: envBudget ?? positiveInt3(config.perWorkerMemBytes, DEFAULT_BUILD_MEM_BUDGET_BYTES),
+    reserveBytes: envReserve ?? positiveInt3(config.memReserveBytes, DEFAULT_BUILD_MEM_RESERVE_BYTES)
+  };
+}
+var activeBuilds = 0;
+function registerBuildStart() {
+  activeBuilds += 1;
+}
+function registerBuildEnd() {
+  activeBuilds = Math.max(0, activeBuilds - 1);
+}
+function assessBuildAdmission(opts = {}) {
+  const cfg = { ...resolveBuildAdmissionConfig(), ...opts };
+  const memAvailableBytes = opts.memAvailableBytes ?? readMemAvailableBytes();
+  const requiredBytes = cfg.perBuildBudgetBytes + cfg.reserveBytes;
+  const admitted = memAvailableBytes >= requiredBytes;
+  return {
+    admitted,
+    memAvailableBytes,
+    requiredBytes,
+    activeBuilds,
+    reason: admitted ? null : `insufficient memory: need ${requiredBytes} bytes available (budget ${cfg.perBuildBudgetBytes} + reserve ${cfg.reserveBytes}), have ${memAvailableBytes}`
+  };
+}
+function sleepMs2(ms) {
+  if (ms <= 0) return;
+  spawnSync4(process.execPath, ["-e", `const d=Date.now()+${Math.floor(ms)};while(Date.now()<d);`], {
+    stdio: "ignore"
+  });
+}
+function waitForBuildAdmission(timeoutMs, pollMs = 2e3, opts = {}) {
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  let verdict = assessBuildAdmission({
+    ...opts,
+    memAvailableBytes: opts.memAvailableBytes?.()
+  });
+  while (!verdict.admitted && Date.now() < deadline) {
+    sleepMs2(Math.min(pollMs, deadline - Date.now()));
+    verdict = assessBuildAdmission({
+      ...opts,
+      memAvailableBytes: opts.memAvailableBytes?.()
+    });
+  }
+  return verdict;
+}
+
+// src/bounded-build/exec.ts
+import { spawnSync as spawnSync5 } from "node:child_process";
+function envArgv(env) {
+  const out = [];
+  for (const [key, value] of Object.entries(env)) {
+    if (value === void 0) continue;
+    out.push(`${key}=${value}`);
+  }
+  return out;
+}
+function runSpawn(argv, opts) {
+  const res = spawnSync5(argv[0], argv.slice(1), {
+    cwd: opts.cwd,
+    env: opts.env,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: opts.shell,
+    timeout: opts.timeoutMs
+  });
+  return {
+    exitCode: res.status ?? 1,
+    stdout: (res.stdout ?? "").trim(),
+    stderr: (res.stderr ?? "").trim()
+  };
+}
+function runBoundedBuildCheck(input) {
+  const waitMs = input.waitForAdmissionMs ?? 6e5;
+  const admission = waitMs > 0 ? waitForBuildAdmission(waitMs) : assessBuildAdmission();
+  if (!admission.admitted) {
+    return {
+      ok: false,
+      exitCode: 1,
+      stdout: "",
+      stderr: admission.reason ?? "build admission denied",
+      admitted: false,
+      wrappedWithSystemd: false,
+      nodeOptionsFlag: formatNodeOptionsFlag(),
+      admission,
+      command: input.command
+    };
+  }
+  const env = mergeNodeOptionsForBuildCheck({ ...process.env, ...input.env });
+  const nodeOptionsFlag = formatNodeOptionsFlag();
+  const useSystemd = isSystemdRunAvailable();
+  registerBuildStart();
+  try {
+    let result;
+    if (useSystemd) {
+      const argv = buildSystemdRunArgv({
+        cwd: input.cwd,
+        command: ["/usr/bin/env", ...envArgv(env), "/bin/bash", "-lc", input.command]
+      });
+      result = runSpawn(argv, { cwd: input.cwd, env, timeoutMs: input.timeoutMs });
+    } else {
+      result = runSpawn([input.command], {
+        cwd: input.cwd,
+        env,
+        shell: true,
+        timeoutMs: input.timeoutMs
+      });
+    }
+    return {
+      ok: result.exitCode === 0,
+      exitCode: result.exitCode,
+      stdout: result.stdout,
+      stderr: result.stderr,
+      admitted: true,
+      wrappedWithSystemd: useSystemd,
+      nodeOptionsFlag,
+      admission,
+      command: input.command
+    };
+  } finally {
+    registerBuildEnd();
+  }
+}
+
+// src/harness-verify.ts
+var DEFAULT_HARNESS_VERIFY_COMMANDS = ["npm run typecheck", "npm run test"];
+function runHarnessVerifyCommands(cwd, commands = DEFAULT_HARNESS_VERIFY_COMMANDS, opts = {}) {
+  const steps = [];
+  let passed = true;
+  for (const command of commands) {
+    const result = runBoundedBuildCheck({
+      cwd,
+      command,
+      waitForAdmissionMs: opts.waitForAdmissionMs,
+      timeoutMs: opts.timeoutMs
+    });
+    steps.push({ command, result });
+    if (!result.ok) passed = false;
+  }
+  return { passed, steps };
+}
+
 // src/plan-progress.ts
 function parseEvidenceArg(raw) {
   const idx = raw.indexOf(":");
@@ -5173,8 +5855,23 @@ async function emitPlanProgress(args) {
   }
   console.log(JSON.stringify(parsed, null, 2));
 }
+function verifyPlanLocal(args) {
+  const worktree = required(args.worktree ? String(args.worktree) : void 0, "worktree");
+  const cwd = path31.resolve(worktree);
+  const summary = runHarnessVerifyCommands(cwd);
+  const emitJson = args.json === true || args.json === "true";
+  const payload = { passed: summary.passed, worktree: cwd, steps: summary.steps };
+  if (emitJson) console.log(JSON.stringify(payload, null, 2));
+  else console.log(summary.passed ? "local plan verify passed" : "local plan verify failed");
+  if (!summary.passed) process.exit(1);
+}
 async function verifyPlan(args) {
   const planId = required(args.plan ? String(args.plan) : void 0, "plan");
+  const localOnly = args.local === true || args.local === "true";
+  if (localOnly) {
+    verifyPlanLocal(args);
+    return;
+  }
   const slug = loadUserConfig().agentOsSlug;
   if (!slug) {
     console.error("requires agentOsSlug in ~/.kynver/config.json for verify (session route)");
@@ -5208,6 +5905,52 @@ async function verifyPlan(args) {
   console.log(JSON.stringify(parsed, null, 2));
 }
 
+// src/harness-verify-cli.ts
+import path32 from "node:path";
+function runHarnessVerifyCli(args) {
+  const cwd = path32.resolve(required(args.worktree ? String(args.worktree) : void 0, "worktree"));
+  const emitJson = args.json === true || args.json === "true" || args.emitJson === true || args.emitJson === "true";
+  const commands = [];
+  const rawCmd = args.command;
+  if (Array.isArray(rawCmd)) {
+    for (const c of rawCmd) commands.push(String(c));
+  } else if (typeof rawCmd === "string") {
+    commands.push(rawCmd);
+  }
+  const summary = runHarnessVerifyCommands(
+    cwd,
+    commands.length ? commands : DEFAULT_HARNESS_VERIFY_COMMANDS,
+    {
+      waitForAdmissionMs: args.waitForAdmissionMs ? Number(args.waitForAdmissionMs) : void 0,
+      timeoutMs: args.timeoutMs ? Number(args.timeoutMs) : void 0
+    }
+  );
+  const payload = {
+    passed: summary.passed,
+    worktree: cwd,
+    steps: summary.steps.map((s) => ({
+      command: s.command,
+      ok: s.result.ok,
+      exitCode: s.result.exitCode,
+      admitted: s.result.admitted,
+      wrappedWithSystemd: s.result.wrappedWithSystemd,
+      nodeOptionsFlag: s.result.nodeOptionsFlag,
+      admission: s.result.admission,
+      stderr: s.result.stderr.slice(0, 4e3)
+    }))
+  };
+  if (emitJson) {
+    console.log(JSON.stringify(payload, null, 2));
+  } else {
+    console.log(summary.passed ? "harness verify passed" : "harness verify failed");
+    for (const step of payload.steps) {
+      console.log(`  ${step.ok ? "\u2713" : "\u2717"} ${step.command} (exit ${step.exitCode}, systemd=${step.wrappedWithSystemd})`);
+      if (!step.ok && step.stderr) console.log(`    ${step.stderr.split("\n")[0]}`);
+    }
+  }
+  process.exit(summary.passed ? 0 : 1);
+}
+
 // src/plan-persist-cli.ts
 import { readFileSync as readFileSync8 } from "node:fs";
 var OPERATIONS = ["create", "add_version", "update_metadata"];
@@ -5309,7 +6052,7 @@ function runCleanupCli(args) {
 }
 
 // src/monitor/monitor.service.ts
-import path31 from "node:path";
+import path34 from "node:path";
 
 // src/monitor/monitor.classify.ts
 function expectedLeaseOwner(runId) {
@@ -5366,10 +6109,10 @@ function classifyWorkerHealth(input) {
 
 // src/monitor/monitor.store.ts
 import { existsSync as existsSync18, mkdirSync as mkdirSync6, readdirSync as readdirSync7, unlinkSync as unlinkSync2 } from "node:fs";
-import path30 from "node:path";
+import path33 from "node:path";
 function monitorsDir() {
   const { harnessRoot } = getHarnessPaths();
-  const dir = path30.join(harnessRoot, "monitors");
+  const dir = path33.join(harnessRoot, "monitors");
   mkdirSync6(dir, { recursive: true });
   return dir;
 }
@@ -5377,7 +6120,7 @@ function monitorIdFor(runId, workerName) {
   return workerName ? `${safeSlug(runId)}--${safeSlug(workerName)}` : safeSlug(runId);
 }
 function monitorPath(monitorId) {
-  return path30.join(monitorsDir(), `${monitorId}.json`);
+  return path33.join(monitorsDir(), `${monitorId}.json`);
 }
 function loadMonitorSession(monitorId) {
   return readJson(monitorPath(monitorId), void 0);
@@ -5398,7 +6141,7 @@ function listMonitorSessions() {
   for (const name of readdirSync7(dir)) {
     if (!name.endsWith(".json")) continue;
     const session = readJson(
-      path30.join(dir, name),
+      path33.join(dir, name),
       void 0
     );
     if (!session?.monitorId) continue;
@@ -5489,7 +6232,7 @@ async function fetchTaskLeasesForWorkers(input) {
 // src/monitor/monitor.service.ts
 function workerRecord2(runId, name) {
   return readJson(
-    path31.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
+    path34.join(runDirectory(runId), "workers", safeSlug(name), "worker.json"),
     void 0
   );
 }
@@ -5692,17 +6435,17 @@ async function runMonitorLoop(args) {
 // src/monitor/monitor-spawn.ts
 import { spawn as spawn4 } from "node:child_process";
 import { closeSync as closeSync4, existsSync as existsSync19, openSync as openSync4 } from "node:fs";
-import path32 from "node:path";
+import path35 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function resolveDefaultCliPath2() {
-  return path32.join(fileURLToPath3(new URL(".", import.meta.url)), "..", "cli.js");
+  return path35.join(fileURLToPath3(new URL(".", import.meta.url)), "..", "cli.js");
 }
 function spawnMonitorSidecar(opts) {
   const cliPath = opts.cliPath ?? resolveDefaultCliPath2();
   if (!existsSync19(cliPath)) return void 0;
   const monitorId = monitorIdFor(opts.runId, opts.workerName);
   const { harnessRoot } = getHarnessPaths();
-  const logPath = path32.join(harnessRoot, "monitors", `${monitorId}.log`);
+  const logPath = path35.join(harnessRoot, "monitors", `${monitorId}.log`);
   let logFd;
   try {
     logFd = openSync4(logPath, "a");
@@ -5822,16 +6565,16 @@ async function monitorTickCli(args) {
 }
 
 // src/doctor/runtime-takeover.ts
-import path34 from "node:path";
+import path37 from "node:path";
 
 // src/doctor/runtime-takeover.probes.ts
 import { accessSync, constants, existsSync as existsSync20, readFileSync as readFileSync9 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import path33 from "node:path";
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { homedir as homedir6 } from "node:os";
+import path36 from "node:path";
+import { spawnSync as spawnSync6 } from "node:child_process";
 function captureCommand(bin, args) {
   try {
-    const res = spawnSync3(bin, args, { encoding: "utf8" });
+    const res = spawnSync6(bin, args, { encoding: "utf8" });
     const stdout = (res.stdout || "").trim();
     const stderr = (res.stderr || "").trim();
     const ok = res.status === 0;
@@ -5869,10 +6612,10 @@ var defaultRuntimeTakeoverProbes = {
   commandOnPath: (bin) => captureCommand(process.platform === "win32" ? "where" : "which", [bin]),
   kynverVersion: (bin) => captureCommand(bin, ["--version"]),
   loadConfig: () => loadUserConfig(),
-  configFilePath: () => path33.join(homedir5(), ".kynver", "config.json"),
-  credentialsFilePath: () => path33.join(homedir5(), ".kynver", "credentials"),
+  configFilePath: () => path36.join(homedir6(), ".kynver", "config.json"),
+  credentialsFilePath: () => path36.join(homedir6(), ".kynver", "credentials"),
   readCredentials: () => {
-    const credPath = path33.join(homedir5(), ".kynver", "credentials");
+    const credPath = path36.join(homedir6(), ".kynver", "credentials");
     if (!existsSync20(credPath)) {
       return { hasApiKey: false };
     }
@@ -5898,7 +6641,7 @@ var defaultRuntimeTakeoverProbes = {
     kynverSchedulerProvider: process.env.KYNVER_SCHEDULER_PROVIDER?.trim() || void 0
   }),
   harnessRoot: () => resolveHarnessRoot(),
-  legacyOpenclawHarnessRoot: () => path33.join(homedir5(), ".openclaw", "harness"),
+  legacyOpenclawHarnessRoot: () => path36.join(homedir6(), ".openclaw", "harness"),
   pathExists: (target) => existsSync20(target),
   pathWritable: (target) => isWritable(target),
   vercelVersion: () => captureCommand("vercel", ["--version"]),
@@ -6084,8 +6827,8 @@ function assessVercelCli(probes) {
 }
 function assessHarnessDirs(probes) {
   const harnessRoot = probes.harnessRoot();
-  const runsDir = path34.join(harnessRoot, "runs");
-  const worktreesDir = path34.join(harnessRoot, "worktrees");
+  const runsDir = path37.join(harnessRoot, "runs");
+  const worktreesDir = path37.join(harnessRoot, "worktrees");
   const displayHarnessRoot = redactHomePath(harnessRoot);
   const displayRunsDir = redactHomePath(runsDir);
   const displayWorktreesDir = redactHomePath(worktreesDir);
@@ -6237,6 +6980,37 @@ function runRuntimeTakeoverDoctorCli() {
   }
 }
 
+// src/command-center-contract-cli.ts
+async function runCommandCenterContractCli(args) {
+  const config = loadUserConfig();
+  const agentOsId = (args.agentOsId ? String(args.agentOsId) : config.agentOsId) || "";
+  if (!agentOsId) {
+    console.error("requires --agent-os-id or agentOsId in ~/.kynver/config.json");
+    process.exit(1);
+  }
+  const base = resolveBaseUrl(args.baseUrl ? String(args.baseUrl) : config.apiBaseUrl);
+  const secret = await resolveCallbackSecretWithMint(
+    args.secret ? String(args.secret) : void 0,
+    agentOsId,
+    { baseUrl: base }
+  );
+  const qs = new URLSearchParams();
+  if (typeof args.since === "string" && args.since.trim()) qs.set("since", args.since.trim());
+  if (args.limit != null && String(args.limit).trim()) {
+    const n = Number(args.limit);
+    if (Number.isFinite(n) && n > 0) qs.set("limit", String(Math.floor(n)));
+  }
+  const suffix = qs.toString() ? `?${qs.toString()}` : "";
+  const url = `${base}/api/agent-os/by-id/${encodeURIComponent(agentOsId)}/command-center/dashboard-contract${suffix}`;
+  const res = await getJson(url, secret);
+  if (!res.ok) {
+    console.error(`dashboard-contract GET failed: HTTP ${res.status}`);
+    if (res.response) console.error(JSON.stringify(res.response, null, 2));
+    process.exit(1);
+  }
+  console.log(JSON.stringify(res.response, null, 2));
+}
+
 // src/cli.ts
 function isHelpFlag(arg) {
   return arg === "help" || arg === "--help" || arg === "-h";
@@ -6258,7 +7032,7 @@ function usage(code = 0) {
       "  kynver run create --repo /path/repo [--name name] [--base origin/main]",
       "  kynver run list",
       "  kynver run status --run RUN_ID",
-      "  kynver run dispatch --run RUN_ID --agent-os-id AOS_ID [--base-url URL] [--secret SECRET] [--execute] [--lane any|implementation|review|landing] [--executor harness] [--max-starts 1] [--lease-ms MS] [--owned path[,path]] [--model claude-opus-4-8] [--disk-path /]",
+      "  kynver run dispatch --run RUN_ID --agent-os-id AOS_ID [--base-url URL] [--secret SECRET] [--execute] [--lane any|implementation|review|landing] [--target-task-id TASK_ID] [--executor harness] [--max-starts 1] [--lease-ms MS] [--owned path[,path]] [--model claude-opus-4-8] [--disk-path /]",
       "  kynver run sweep --run RUN_ID --agent-os-id AOS_ID [--base-url URL] [--secret SECRET] [--grace-ms MS]",
       '  kynver worker start --run RUN_ID --name worker --task "..." [--owned path[,path]] [--model MODEL] [--provider claude|cursor] [--agent-os-id AOS_ID] [--task-id TASK_ID] [--wait]',
       "  kynver worker status --run RUN_ID --name worker",
@@ -6268,7 +7042,8 @@ function usage(code = 0) {
       "  kynver worker auto-complete --run RUN_ID --name worker [--agent-os-id AOS_ID] [--poll-ms 5000] [--max-total-ms 21600000] [--complete-attempts 3] [--complete-backoff-ms 5000] [--base-url URL] [--secret SECRET]",
       "  kynver run reconcile",
       "  kynver plan progress --plan PLAN_ID --row ROW_KEY --role ROLE --status STATUS [--task TASK_ID] [--note NOTE] [--evidence type:value] [--agent-os-id AOS_ID]",
-      "  kynver plan verify --plan PLAN_ID [--worktree PATH] [--task TASK_ID] [--human-override]",
+      "  kynver plan verify --plan PLAN_ID [--worktree PATH] [--task TASK_ID] [--human-override] [--local]",
+      "  kynver harness verify --worktree PATH [--command CMD] [--json] [--wait-for-admission-ms MS] [--timeout-ms MS]",
       "  kynver plan persist --operation create|add_version|update_metadata --title TITLE (--body-file PATH | --body TEXT) [--slug SLUG] [--plan PLAN_ID] [--summary TEXT] [--failure-kind approval_guard|auth|network|server|tool_interruption]",
       "  kynver plan outbox list",
       "  kynver plan outbox drain [--max N] [--id OUTBOX_ID]",
@@ -6280,7 +7055,8 @@ function usage(code = 0) {
       "  kynver monitor tick --run RUN_ID [--name worker] [--agent-os-id AOS_ID] [--auto-complete] [--renew-leases]",
       "  kynver monitor auto-complete --run RUN_ID --name worker [--agent-os-id AOS_ID] [--base-url URL] [--secret SECRET]",
       "  kynver monitor run-loop --run RUN_ID --monitor-id ID [--name worker] [--agent-os-id AOS_ID] [--poll-ms MS] [--auto-complete] [--renew-leases]",
-      "  kynver doctor runtime-takeover"
+      "  kynver doctor runtime-takeover",
+      "  kynver board contract [--agent-os-id ID] [--base-url URL] [--since ISO] [--limit N]"
     ].join("\n")
   );
   process.exit(code);
@@ -6291,7 +7067,7 @@ async function main(argv = process.argv.slice(2)) {
   const scope = argv.shift();
   let action;
   let rest;
-  if (scope === "run" || scope === "worker" || scope === "plan" || scope === "runner" || scope === "monitor" || scope === "doctor") {
+  if (scope === "run" || scope === "worker" || scope === "plan" || scope === "runner" || scope === "harness" || scope === "monitor" || scope === "doctor" || scope === "board") {
     action = argv.shift();
     rest = argv;
   } else {
@@ -6308,6 +7084,7 @@ async function main(argv = process.argv.slice(2)) {
   if (scope === "daemon") return void await runDaemon(args);
   if (scope === "plan" && action === "progress") return void await emitPlanProgress(args);
   if (scope === "plan" && action === "verify") return void await verifyPlan(args);
+  if (scope === "harness" && action === "verify") return runHarnessVerifyCli(args);
   if (scope === "plan" && action === "persist") return void await runPlanPersist(args);
   if (scope === "plan" && action === "outbox") {
     const outboxAction = rest.shift();
@@ -6317,6 +7094,9 @@ async function main(argv = process.argv.slice(2)) {
   }
   if (scope === "cleanup") return runCleanupCli(args);
   if (scope === "doctor" && action === "runtime-takeover") return runRuntimeTakeoverDoctorCli();
+  if (scope === "board" && action === "contract") {
+    return void await runCommandCenterContractCli(args);
+  }
   if (scope === "run" && action === "create") return createRun(args);
   if (scope === "run" && action === "list") return listRuns();
   if (scope === "run" && action === "status") return runStatus(args);
@@ -6443,10 +7223,10 @@ function pickVercelStatusContext(statuses) {
     return 1;
   };
   let best = null;
-  let bestScore = -1;
+  let bestScore = Infinity;
   for (const row of vercelRows) {
     const rowScore = score(normalizeGitHubStatusState(row.state));
-    if (rowScore > bestScore) {
+    if (rowScore < bestScore) {
       best = row;
       bestScore = rowScore;
     }
@@ -6466,7 +7246,7 @@ function pickVercelStatusContext(statuses) {
 }
 
 // src/vercel/vercel-evidence.ts
-import { spawnSync as spawnSync4 } from "node:child_process";
+import { spawnSync as spawnSync7 } from "node:child_process";
 var DEFAULT_INSPECT_WAIT_SECONDS = 120;
 function mapGitHubStateToEvidence(state) {
   if (state === "success") return "ready";
@@ -6532,7 +7312,7 @@ function evidenceFromGitHubVercelStatus(statuses, options = {}) {
 }
 function defaultRunVercelInspect(target, waitSeconds) {
   const args = ["inspect", target, "--wait", String(waitSeconds)];
-  const result = spawnSync4("vercel", args, {
+  const result = spawnSync7("vercel", args, {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -6640,16 +7420,23 @@ function collectVercelEvidence(input) {
 }
 export {
   DEFAULT_DISPATCH_LEASE_MS,
+  DEFAULT_HARNESS_VERIFY_COMMANDS,
+  FORBIDDEN_WORKER_ENV_KEYS,
   PACKAGE_VERSION,
   assessAutoCompleteEligibility,
+  assessBuildAdmission,
   assessExitedWorkerSalvage,
   assessPrHandoffRequirement,
   assessWorkerLanding,
   assessWorkerLandingContract,
+  auditWorkerEnv,
   autoCompleteWorker,
   autoCompleteWorkerCli,
   buildDispatchTaskText,
   buildPrompt,
+  buildSystemdRunArgv,
+  classifyNpmAuditOutcome,
+  classifyShellCommandOutcome,
   classifyVercelUrl,
   classifyWorkerHealth,
   collectVercelEvidence,
@@ -6669,16 +7456,21 @@ export {
   getMonitorStatus,
   hashPlanBody,
   isDashboardVercelUrl,
+  isEngagementRequiredSkip,
   isFinishedWorkerStatus,
+  isForbiddenWorkerEnvKey,
   isLandingBlockedWorkerStatus,
+  isSystemdRunAvailable,
   isTerminalHeartbeatPhase,
   isVercelStatusContext,
   landingContractAttentionReason,
+  listForbiddenWorkerEnvKeys,
   listMonitors,
   listOutboxItems,
   listRuns,
   loadUserConfig,
   main,
+  mergeNodeOptionsForBuildCheck,
   normalizeCursorModelAlias,
   observeRunnerDiskGate,
   parseArgs,
@@ -6689,6 +7481,7 @@ export {
   pickVercelStatusContext,
   postJson,
   preflightCursorModel,
+  readMemAvailableBytes,
   reconcileRunsCli,
   reconcileStaleWorkers,
   redactHarness,
@@ -6697,16 +7490,22 @@ export {
   resolveCallbackSecretWithMint,
   resolveHarnessRoot,
   resolveVercelInspectTarget,
+  runBoundedBuildCheck,
   runDaemon,
+  runHarnessVerifyCommands,
   runMonitorTick,
   runStatus,
   saveUserConfig,
+  scrubClaudeEnv,
+  scrubWorkerEnv,
   spawnCompletionSidecar,
   spawnMonitorSidecar,
   spawnWorkerProcess,
   startWorker,
   stopWorker,
   summarizeEvent,
+  summarizeNpmAuditReport,
+  summarizeShellToolCallEvent,
   sweepRun,
   tailWorker,
   terminalFinalResultFromHeartbeat,