nolo-cli 0.212.0-alpha.1 → 0.222.0-alpha.2

package/{chunk-HIRC32DV.js → chunk-2GJKRKI6.js}

@@ -1,21 +1,25 @@
 import {
   resolveRuntimeAuthToken,
   resolveRuntimeServerUrl
-} from "./chunk-HRMJUN5J.js";
+} from "./chunk-AQZ6BMRK.js";
 import {
   isAgentRunTerminalStatus,
-  normalizeRunTitle
-} from "./chunk-PJNFNEJE.js";
+  normalizeRunTitle,
+  shortAgentKey
+} from "./chunk-AMEOV5VZ.js";
 import {
   findPowerShellExecutable
-} from "./chunk-JNKSDZFS.js";
+} from "./chunk-KEN3N2TN.js";
+import {
+  AUTH_ERROR_PATTERNS
+} from "./chunk-EWQ3HGNZ.js";
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";
 import {
   isCompiledBinary,
   resolveCliEntrypointPath
-} from "./chunk-WACI5I6V.js";
+} from "./chunk-2THCNKE4.js";
 
 // packages/cli/client/originShellApprovalTransport.ts
 import { realpathSync } from "node:fs";
@@ -444,9 +448,10 @@ function redactLogLines(lines, options = {}) {
 }
 
 // packages/cli/agentRunControl.ts
-import { homedir as nodeHomedir } from "node:os";
+import { hostname as nodeHostname, homedir as nodeHomedir } from "node:os";
 import { dirname, isAbsolute as isAbsolute2, join as join2, resolve } from "node:path";
 import * as nodeFs2 from "node:fs";
+import { randomUUID as randomUUID2, createHash } from "node:crypto";
 import { execFileSync as nodeExecFileSync, spawn as nodeSpawn } from "node:child_process";
 
 // packages/cli/client/hostMemory.ts
@@ -1090,6 +1095,7 @@ function resolveResultServerMeta(input) {
 var resultHeaderMeta = /* @__PURE__ */ new WeakMap();
 function recordRunResultHeaderMeta(result, meta) {
   const clean = {};
+  if (meta.commandObservations?.length) clean.commandObservations = meta.commandObservations;
   if (meta.model) clean.model = meta.model;
   if (meta.dialogServer) clean.dialogServer = meta.dialogServer;
   if (meta.serverSync) clean.serverSync = meta.serverSync;
@@ -1134,7 +1140,8 @@ function buildResultFrontMatter(input) {
     ["server", input.server],
     ["serverSync", input.serverSync],
     ["cwd", input.cwd],
-    ["continuedFrom", input.continuedFrom]
+    ["continuedFrom", input.continuedFrom],
+    ["acceptance", input.acceptance ? JSON.stringify(input.acceptance) : void 0]
   ];
   const lines = entries.filter(([, v]) => v !== void 0 && v !== "").map(([k, v]) => `${k}: ${yamlScalar(v)}`);
   return `---
@@ -1145,9 +1152,18 @@ ${lines.join("\n")}
 function buildResultFileContent(input, body) {
   return `${buildResultFrontMatter(input)}${body}`;
 }
+var RESULT_FRONT_MATTER_RE = /^---\nrunId: [^\n]*\n(?:[^\n]*\n)*?---\n/;
+function stripResultFrontMatter(text) {
+  const match = RESULT_FRONT_MATTER_RE.exec(text);
+  return match ? text.slice(match[0].length) : text;
+}
 
 // packages/ai/tools/agent/runFailureClass.ts
-var RATE_LIMIT_PATTERN = /429|rate.?limit|quota|insufficient.?balance|UPSTREAM_402|cooling|冷却/i;
+function isHistoryIntegrityFailure(message) {
+  return /^Strict continuation history load failed for [^\r\n]+:/i.test(message.trim());
+}
+var BALANCE_PATTERN = /\bUPSTREAM_402\b|\b402\b|insufficient[_\s-]+balance|余额不足|wallet\s+balance\s+is\s+insufficient|top\s+up\s+your\s+wallet|payment[_ ]required/i;
+var RATE_LIMIT_PATTERN = /429|rate.?limit|quota|cooling|冷却/i;
 var PROVIDER_ERROR_PATTERN = /provider|upstream|5\d\d|bad.?gateway|service.?unavailable|overloaded/i;
 var MALFORMED_PATTERN = /MALFORMED_FUNCTION_CALL|malformed|invalid.?function.?call|invalid.?tool.?call/i;
 var STALLED_PATTERN = /stall|no.?progress|repetition|stagnant|无进展|卡死/i;
@@ -1159,6 +1175,20 @@ function classifyRunFailure(input) {
   }
   const reason = typeof input.failureReason === "string" ? input.failureReason : "";
   const message = typeof input.errorMessage === "string" ? input.errorMessage : "";
+  if (reason === "history_integrity" || isHistoryIntegrityFailure(message)) {
+    return { failureClass: "history_integrity", retryable: false };
+  }
+  if (!reason || reason === "provider_rate_limited" || reason === "provider_error") {
+    if (BALANCE_PATTERN.test(message)) {
+      return { failureClass: "balance_exhausted", retryable: false };
+    }
+    if (AUTH_ERROR_PATTERNS.some((pattern) => pattern.test(message))) {
+      return { failureClass: "auth", retryable: false };
+    }
+    if (reason === "provider_error" && RATE_LIMIT_PATTERN.test(message)) {
+      return { failureClass: "rate_limited", retryable: true };
+    }
+  }
   switch (reason) {
     case "provider_rate_limited":
       return { failureClass: "rate_limited", retryable: true };
@@ -1552,7 +1582,9 @@ function withRunRecordLock(runId, deps, fn, opts = {}) {
       try {
         const stat = fs.statSync?.(lockPath);
         const ageMs = stat ? now().getTime() - stat.mtimeMs : Number.POSITIVE_INFINITY;
-        if (ageMs > LOCK_STALE_MS) {
+        const ownerPid = opts.requireDeadOwner ? Number(String(fs.readFileSync(lockPath, "utf8"))) : void 0;
+        const ownerGone = !opts.requireDeadOwner || Number.isSafeInteger(ownerPid) && ownerPid > 0 && isPidGone(ownerPid, deps);
+        if (ageMs > LOCK_STALE_MS && ownerGone) {
           fs.unlinkSync(lockPath);
           fs.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
           held = true;
@@ -1582,13 +1614,15 @@ function writeRunRecord(record, deps = {}) {
       fs.writeFileSync(tmp, payload);
       fs.renameSync(tmp, path);
       return;
-    } catch {
+    } catch (error) {
       try {
         fs.unlinkSync(tmp);
       } catch {
       }
+      if (record.writerLaunch) throw error;
     }
   }
+  if (record.writerLaunch) throw new Error("[local-writer-resource] fenced launch requires atomic rename");
   fs.writeFileSync(path, payload);
 }
 function reportRunProcessIdentity(runId, deps = {}) {
@@ -2054,9 +2088,18 @@ async function gcRunRecords(deps = {}, options = {}) {
   const failedIds = [];
   for (const record of records) {
     if (!isRunTerminalStatus(record.status)) continue;
+    if (localWriterStillOwns(record, deps)) continue;
+    if (!/^[A-Za-z0-9._-]{1,128}$/.test(record.runId) || record.runId === "." || record.runId === "..") {
+      failedIds.push(record.runId);
+      continue;
+    }
     const ts = record.reconciledAt ?? record.endedAt ?? record.startedAt;
     const ageMs = nowMs - new Date(ts).getTime();
     if (!Number.isFinite(ageMs) || ageMs < retentionMs) continue;
+    if (fs.existsSync(`${resolveRunRecordPath(record.runId, deps.env, deps.homedir)}.lock`)) {
+      failedIds.push(record.runId);
+      continue;
+    }
     const jsonPath = resolveRunRecordPath(record.runId, deps.env, deps.homedir);
     const logPath = resolveRunLogPath(record.runId, deps.env, deps.homedir);
     const queuePath = record.queuePath ?? resolveRunQueuePath(record.runId, deps.env, deps.homedir);
@@ -2076,8 +2119,30 @@ async function gcRunRecords(deps = {}, options = {}) {
     const runsDirForLegacy = resolveRunsDir(deps.env, deps.homedir);
     tryUnlinkFile(fs, join2(runsDirForLegacy, `${record.runId}.report.md`));
     tryUnlinkFile(fs, join2(runsDirForLegacy, `${record.runId}.report.json`));
-    tryUnlinkFile(fs, record.resultFile ?? join2(runsDirForLegacy, `${record.runId}.result.md`));
-    if (!logOk || !msgOk || !queueOk) {
+    let resultOk = false;
+    let artifactsOk = true;
+    const artifactSweep = withRunRecordLock(record.runId, deps, () => {
+      resultOk = tryUnlinkFile(fs, join2(runsDirForLegacy, `${record.runId}.result.md`));
+      for (const artifact of record.resultArtifacts ?? []) {
+        try {
+          const prefix = `${record.runId}.result.md.`;
+          const name = artifact.path.slice(join2(runsDirForLegacy, prefix).length);
+          const uuid = "[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}";
+          if (artifact.publisher !== "run-result-v1" || !/^[A-Za-z0-9._-]+$/.test(record.runId) || !["pending", "bak"].includes(artifact.kind) || !new RegExp(`^${uuid}\\.${artifact.kind}$`).test(name) || artifact.path !== join2(runsDirForLegacy, prefix + name)) throw new Error("unsafe artifact ownership");
+          if (!fs.existsSync(artifact.path)) continue;
+          const stat = fs.lstatSync?.(artifact.path);
+          if (!stat || !stat.isFile() || stat.isSymbolicLink() || fs.realpathSync?.(artifact.path) !== resolve(artifact.path) || String(stat.dev) !== artifact.dev || String(stat.ino) !== artifact.ino || createHash("sha256").update(fs.readFileSync(artifact.path)).digest("hex") !== artifact.sha256) {
+            throw new Error("artifact identity changed");
+          }
+          if (!tryUnlinkFile(fs, artifact.path)) artifactsOk = false;
+        } catch {
+          artifactsOk = false;
+        }
+      }
+      return true;
+    }, { strict: true });
+    if (!artifactSweep) artifactsOk = false;
+    if (!logOk || !msgOk || !queueOk || !resultOk || !artifactsOk) {
       failedIds.push(record.runId);
       continue;
     }
@@ -2090,12 +2155,12 @@ async function gcRunRecords(deps = {}, options = {}) {
   }
   try {
     const dir = resolveRunsDir(deps.env, deps.homedir);
-    const statSync = fs.statSync;
+    const statSync2 = fs.statSync;
     for (const entry of fs.readdirSync(dir)) {
       if (typeof entry !== "string" || !entry.endsWith(".tmp")) continue;
       const tmpPath = join2(dir, entry);
       try {
-        const stat = statSync?.(tmpPath);
+        const stat = statSync2?.(tmpPath);
         if (stat && nowMs - stat.mtimeMs <= TMP_STALE_MS) continue;
       } catch {
         continue;
@@ -2210,6 +2275,270 @@ function emitHostMemoryNotice(mem, output) {
   }
   return notice;
 }
+function trustedLocalWorktree(cwd, deps) {
+  const fs = deps.fs ?? nodeFs2;
+  try {
+    const env = { ...process.env, ...deps.env };
+    for (const key of Object.keys(env)) if (key.startsWith("GIT_")) delete env[key];
+    const exec = deps.execFileSync ?? nodeExecFileSync;
+    const git = (args) => exec("git", args, {
+      cwd,
+      env,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 3e3
+    }).trim();
+    const real = (path) => String((fs.realpathSync ?? nodeFs2.realpathSync)(path));
+    const [dir, top, common] = git(["rev-parse", "--path-format=absolute", "--git-dir", "--show-toplevel", "--git-common-dir"]).split("\n");
+    if (!dir || !top || !common || ![dir, top, common].every(isAbsolute2)) return;
+    const root = real(top), gitDir = real(dir), commonDir = real(common);
+    const marker = join2(root, ".git");
+    const stat = (path) => (fs.lstatSync ?? nodeFs2.lstatSync)(path);
+    if (stat(marker).isSymbolicLink() || stat(commonDir).isSymbolicLink()) return;
+    if (gitDir === commonDir) {
+      if (!stat(marker).isDirectory() || real(marker) !== commonDir) return;
+    } else {
+      const registry = join2(commonDir, "worktrees");
+      if (stat(registry).isSymbolicLink() || dirname(gitDir) !== real(registry) || !stat(gitDir).isDirectory() || stat(gitDir).isSymbolicLink() || !stat(marker).isFile()) return;
+      const text = String(fs.readFileSync(marker, "utf8")).trim();
+      if (!text.startsWith("gitdir: ") || real(resolve(root, text.slice(8))) !== gitDir) return;
+      const back = String(fs.readFileSync(join2(gitDir, "gitdir"), "utf8")).trim();
+      const commonBack = String(fs.readFileSync(join2(gitDir, "commondir"), "utf8")).trim();
+      if (real(resolve(gitDir, back)) !== real(marker) || real(resolve(gitDir, commonBack)) !== commonDir) return;
+    }
+    const registered = git(["worktree", "list", "--porcelain"]).split("\n").filter((line) => line.startsWith("worktree ")).map((line) => line.slice(9));
+    if (!registered.some((path) => real(path) === root)) return;
+    const mainMarker = registered[0] && join2(registered[0], ".git");
+    if (!mainMarker || stat(mainMarker).isSymbolicLink() || !stat(mainMarker).isDirectory() || real(mainMarker) !== commonDir) return;
+    return { root, gitDir, commonDir };
+  } catch {
+    return;
+  }
+}
+function localWriterRecovery(record) {
+  if (record.localWriterClaim?.state !== "held" || typeof record.pid === "number" && record.pid > 0) return;
+  return {
+    state: "required",
+    reason: "owner-unpublished",
+    automaticReleaseAllowed: false,
+    runId: record.runId,
+    canonicalCwd: record.localWriterClaim.cwd,
+    requiredEvidence: "native launch receipt proving no live child; parent death/timeouts/process-name search are insufficient"
+  };
+}
+function revokePreparedWriterLaunch(runId, attemptId, deps = {}) {
+  if (!/^[A-Za-z0-9_-]+$/.test(runId) || !attemptId) return "blocked";
+  return withRunRecordLock("local-writer-admission", deps, () => {
+    const snapshot = readRunRecord(runId, deps);
+    if (!snapshot) return "blocked";
+    return withRunRecordLock(runId, deps, () => {
+      const latest = readRunRecord(runId, deps);
+      if (!latest || JSON.stringify(latest) !== JSON.stringify(snapshot)) return "blocked";
+      const launch = latest.writerLaunch;
+      if (launch?.protocol !== "fenced-launch-v1" || launch.attemptId !== attemptId) return "blocked";
+      if (launch.phase === "revoked") return latest.localWriterClaim?.state === "released" ? "already-revoked" : "blocked";
+      if (launch.phase !== "prepared" || latest.localWriterClaim?.state !== "held" || latest.execution?.state !== "known" || latest.execution.owner.state !== "unknown" || latest.execution.canonicalCwd !== latest.localWriterClaim.cwd || latest.pid !== void 0 || latest.cwd !== latest.localWriterClaim.cwd || latest.execution.kind !== "host-local" || latest.execution.permissions.readOnly || !latest.execution.permissions.hostWritesAuthorized) return "blocked";
+      launch.phase = "revoked";
+      latest.localWriterClaim.state = "released";
+      writeRunRecord(latest, deps);
+      return "revoked";
+    }, { strict: true, requireDeadOwner: true }) ?? "blocked";
+  }, { strict: true, requireDeadOwner: true }) ?? "blocked";
+}
+function localWriterStillOwns(record, deps) {
+  if (record.localWriterClaim?.state !== "held") return false;
+  if (typeof record.pid !== "number" || record.pid <= 0) return true;
+  const e = record.execution;
+  const observed = e?.state === "known" && e.owner.state === "verified" ? nativeOwner(record.pid, deps) : void 0;
+  const reused = observed?.state === "verified" && e?.state === "known" && e.owner.state === "verified" && (observed.startedAt !== e.owner.startedAt || (observed.linux?.bootId !== e.owner.linux?.bootId || observed.linux?.startTicks !== e.owner.linux?.startTicks));
+  if (!isPidGone(record.pid, deps) && !reused) return true;
+  const snapshot = JSON.stringify(record);
+  const released = withRunRecordLock(record.runId, deps, () => {
+    const latest = readRunRecord(record.runId, deps);
+    if (!latest || JSON.stringify(latest) !== snapshot) return false;
+    latest.localWriterClaim.state = "released";
+    writeRunRecord(latest, deps);
+    return true;
+  }, { strict: true });
+  return released !== true;
+}
+function acquireLocalWriterClaim(runId, cwd, deps) {
+  const fs = deps.fs ?? nodeFs2;
+  const canonical = String((fs.realpathSync ?? nodeFs2.realpathSync)(cwd));
+  const worktree = trustedLocalWorktree(canonical, deps);
+  const acquired = withRunRecordLock("local-writer-admission", deps, () => {
+    const updated = withRunRecordLock(runId, deps, () => {
+      const record = readRunRecord(runId, deps);
+      if (!record) throw new Error(`[local-writer-resource] missing run ${runId}`);
+      if (record.writerLaunch?.phase === "revoked") throw new Error("[local-writer-resource] claim attempt revoked");
+      record.localWriterClaim = { cwd: canonical, ...worktree ? { worktree } : {}, state: "held" };
+      if (record.writerLaunch && record.execution?.state === "known" && record.execution.owner.state === "verified" && record.pid === process.pid) {
+        record.writerLaunch.phase = "granted";
+      }
+      writeRunRecord(record, deps);
+      return true;
+    }, { strict: true });
+    if (!updated) throw new Error(`[local-writer-resource] run lock busy: ${runId}`);
+    return true;
+  }, { strict: true, requireDeadOwner: true });
+  if (!acquired) throw new Error("[local-writer-resource] admission lock busy; no child spawned");
+  return canonical;
+}
+function nativeOwner(pid, deps) {
+  const first = probeProcessStartTime(pid, deps);
+  let linux;
+  if ((deps.platform ?? process.platform) === "linux") {
+    try {
+      const stat = nodeFs2.readFileSync(`/proc/${pid}/stat`, "utf8");
+      const startTicks = stat.slice(stat.lastIndexOf(")") + 2).split(/\s+/)[19];
+      const bootId = nodeFs2.readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim();
+      if (/^\d+$/.test(startTicks) && bootId) linux = { startTicks, bootId };
+    } catch {
+      return { state: "unknown" };
+    }
+  }
+  const second = probeProcessStartTime(pid, deps);
+  if (!first || !second || first.getTime() !== second.getTime() || isPidGone(pid, deps) || (deps.platform ?? process.platform) === "linux" && !linux) return { state: "unknown" };
+  return { state: "verified", pid, startedAt: first.toISOString(), source: "parent-native", ...linux ? { linux } : {} };
+}
+function validateLocalWriterChild(runId, cwd, policy, deps = {}) {
+  const fail = (reason = "facts") => {
+    throw new Error(`[local-writer-resource] child binding unknown or mismatched: ${reason}`);
+  };
+  if (!/^[A-Za-z0-9_-]+$/.test(runId)) fail();
+  const validated = withRunRecordLock(runId, deps, () => {
+    const r = readRunRecord(runId, deps), e = r?.execution;
+    const launch = r?.writerLaunch;
+    if (launch && (launch.protocol !== "fenced-launch-v1" || launch.phase !== "granted" || launch.attemptId !== deps.env?.NOLO_WRITER_LAUNCH_ATTEMPT)) fail("launch grant missing/revoked");
+    const native = nativeOwner(process.pid, deps);
+    const real = String((deps.fs?.realpathSync ?? nodeFs2.realpathSync)(cwd));
+    if (!r || r.runId !== runId || r.pid !== process.pid || r.status !== "running" || e?.state !== "known" || e.kind !== "host-local" || e.runtimeKey !== "local" || e.device.kind !== "localhost" || e.device.hostname !== nodeHostname() || e.device.platform !== process.platform || !["cli-command-authorized", "cli-tool-dispatch-authorized"].includes(e.provenance) || e.owner.state !== "verified" || native.state !== "verified" || e.owner.pid !== process.pid || e.owner.startedAt !== native.startedAt || (e.owner.linux?.bootId !== native.linux?.bootId || e.owner.linux?.startTicks !== native.linux?.startTicks) || r.processIdentity !== "verified" || r.processStartedAt !== e.owner.startedAt || e.canonicalCwd !== real || r.cwd !== real || e.permissions.hostWritesAuthorized !== policy.hostWritesAuthorized || e.permissions.readOnly !== policy.readOnly) fail("native identity/authorization");
+    if (e?.state !== "known") return fail();
+    const set = (v) => JSON.stringify(v === void 0 ? null : [...new Set(v)].sort());
+    if (set(e.permissions.allowedToolNames) !== set(policy.allowedToolNames) || set(e.permissions.blockedToolNames) !== set(policy.blockedToolNames) || JSON.stringify(e.worktree) !== JSON.stringify(trustedLocalWorktree(real, deps))) fail("scope/worktree");
+    if (!policy.readOnly && (!policy.hostWritesAuthorized || r?.localWriterClaim?.state !== "held" || r.localWriterClaim.cwd !== real || e.worktree && (r.localWriterClaim.worktree?.root !== e.worktree.root || r.localWriterClaim.worktree.gitDir !== e.worktree.gitDir))) fail();
+    return true;
+  }, { strict: true, requireDeadOwner: true });
+  if (!validated) fail("registry lock busy");
+}
+async function awaitLocalWriterChild(runId, cwd, policy, deps = {}) {
+  if (!/^[A-Za-z0-9_-]+$/.test(runId)) throw new Error("[local-writer-resource] child binding invalid id");
+  const deadline = Date.now() + 2e3;
+  for (; ; ) {
+    const r = readRunRecord(runId, deps);
+    const publication = r?.ownerPublication;
+    if (r?.writerLaunch && (r.writerLaunch.phase === "revoked" || r.writerLaunch.attemptId !== deps.env?.NOLO_WRITER_LAUNCH_ATTEMPT)) {
+      throw new Error("[local-writer-resource] child binding launch revoked/mismatched");
+    }
+    const native = publication ? nativeOwner(publication.parent.pid, deps) : { state: "unknown" };
+    const parentLive = publication && native.state === "verified" && publication.parent.startedAt === native.startedAt && publication.parent.linux?.bootId === native.linux?.bootId && publication.parent.linux?.startTicks === native.linux?.startTicks;
+    try {
+      validateLocalWriterChild(runId, cwd, policy, deps);
+      return;
+    } catch (error) {
+      const lockBusy = String(error).includes("registry lock busy");
+      const pending = publication?.state === "pending" && r?.execution?.state === "known" && r.execution.owner.state === "unknown";
+      if (!parentLive || !pending && !lockBusy || Date.now() >= deadline) throw error;
+      await new Promise((resolve2) => setTimeout(resolve2, 20));
+    }
+  }
+}
+function resolveLocalContinuation(record, deps = {}) {
+  const fail = (why) => {
+    throw new Error(`[local-continuation] ${why}; dispatch a fresh explicitly authorized run`);
+  };
+  const e = record.execution;
+  if (e?.state !== "known" || e.kind !== "host-local" || e.runtimeKey !== "local" || e.device?.kind !== "localhost" || e.device.hostname !== nodeHostname() || e.device.platform !== process.platform || !["cli-command-authorized", "cli-tool-dispatch-authorized"].includes(e.provenance) || typeof e.permissions?.readOnly !== "boolean" || typeof e.permissions.hostWritesAuthorized !== "boolean" || !e.permissions.readOnly && !e.permissions.hostWritesAuthorized) return fail("execution unknown or unsupported");
+  const lists = [e.permissions.allowedToolNames, e.permissions.blockedToolNames];
+  if (lists.some((v) => v !== void 0 && (!Array.isArray(v) || v.some((t) => typeof t !== "string" || !t || t.startsWith("--"))))) return fail("tool scope invalid");
+  let cwd;
+  try {
+    if (!e.canonicalCwd || !isAbsolute2(e.canonicalCwd) || record.cwd !== e.canonicalCwd) return fail("cwd identity missing");
+    const fs = deps.fs ?? nodeFs2;
+    cwd = String((fs.realpathSync ?? nodeFs2.realpathSync)(e.canonicalCwd));
+    if (cwd !== e.canonicalCwd || !(fs.statSync ?? nodeFs2.statSync)(cwd).isDirectory()) return fail("cwd drift");
+    if (JSON.stringify(e.worktree) !== JSON.stringify(trustedLocalWorktree(cwd, deps))) return fail("cwd worktree changed");
+  } catch {
+    return fail("cwd missing or moved");
+  }
+  const death = record.ownerDeath;
+  const hasDeath = !record.pid && death && death.pid > 0 && JSON.stringify(death.executionOwner) === JSON.stringify(e.owner) && (!record.localWriterClaim || record.localWriterClaim.state === "released");
+  if (!hasDeath && (typeof record.pid !== "number" || record.pid <= 0)) return fail("old owner unknown");
+  const current = hasDeath ? { state: "unknown" } : nativeOwner(record.pid, deps);
+  const old = e.owner;
+  const reused = old?.state === "verified" && current.state === "verified" && (old.pid !== current.pid || old.startedAt !== current.startedAt || old.linux?.bootId !== current.linux?.bootId || old.linux?.startTicks !== current.linux?.startTicks);
+  if (!hasDeath && !isPidGone(record.pid, deps) && !reused) return fail("old owner live or unknown");
+  if (!e.permissions.readOnly && (record.localWriterClaim?.cwd !== cwd || !["held", "released"].includes(record.localWriterClaim.state))) return fail("writer claim unknown");
+  const policy = { runtimeKey: "local", ...e.permissions, provenance: "cli-tool-dispatch-authorized" };
+  const rawArgs = [
+    "--runtime-key",
+    "local",
+    ...policy.hostWritesAuthorized ? ["--allow-host-writes"] : [],
+    ...policy.readOnly ? ["--read-only"] : [],
+    ...(policy.allowedToolNames ?? []).flatMap((t) => ["--allowed-tool", t]),
+    ...(policy.blockedToolNames ?? []).flatMap((t) => ["--blocked-tool", t])
+  ];
+  return { cwd, policy, rawArgs };
+}
+function registerLocalForegroundWriter(cwd, policy, agentKey, deps = {}) {
+  const fs = deps.fs ?? nodeFs2;
+  const canonical = String((fs.realpathSync ?? nodeFs2.realpathSync)(cwd));
+  const owner = nativeOwner(process.pid, deps);
+  if (owner.state !== "verified" || policy.readOnly || !policy.hostWritesAuthorized) {
+    throw new Error("[local-writer-resource] foreground native identity/authorization unknown");
+  }
+  const runId = defaultGenerateRunId();
+  fs.mkdirSync(resolveRunsDir(deps.env, deps.homedir), { recursive: true });
+  const worktree = trustedLocalWorktree(canonical, deps);
+  const record = {
+    runId,
+    agentKey,
+    writerLaunch: { protocol: "fenced-launch-v1", attemptId: randomUUID2(), phase: "prepared" },
+    cwd: canonical,
+    startedAt: (deps.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+    status: "running",
+    logPath: resolveRunLogPath(runId, deps.env, deps.homedir),
+    pid: process.pid,
+    processStartedAt: owner.startedAt,
+    processIdentity: "verified",
+    execution: {
+      state: "known",
+      kind: "host-local",
+      runtimeKey: "local",
+      canonicalCwd: canonical,
+      device: { kind: "localhost", hostname: nodeHostname(), platform: process.platform },
+      ...worktree ? { worktree } : {},
+      permissions: {
+        hostWritesAuthorized: policy.hostWritesAuthorized,
+        readOnly: policy.readOnly,
+        ...policy.allowedToolNames ? { allowedToolNames: [...policy.allowedToolNames] } : {},
+        ...policy.blockedToolNames ? { blockedToolNames: [...policy.blockedToolNames] } : {}
+      },
+      provenance: policy.provenance,
+      owner
+    }
+  };
+  writeRunRecord(record, deps);
+  try {
+    acquireLocalWriterClaim(runId, canonical, deps);
+  } catch (error) {
+    finalizeRunRecord(runId, { status: "failed", exitCode: 1, note: String(error) }, deps);
+    throw error;
+  }
+  return runId;
+}
+function releaseUnspawnedLocalWriterClaim(runId, deps) {
+  const released = withRunRecordLock(runId, deps, () => {
+    const record = readRunRecord(runId, deps);
+    if (record?.localWriterClaim) {
+      if (record.writerLaunch?.phase === "prepared") record.writerLaunch.phase = "revoked";
+      record.localWriterClaim.state = "released";
+      writeRunRecord(record, deps);
+    }
+    return true;
+  }, { strict: true });
+  if (!released) throw new Error(`[local-writer-resource] release lock busy: ${runId}`);
+}
 async function spawnLocalBackgroundRun(input, deps = {}) {
   const homedir = deps.homedir ?? nodeHomedir;
   const env = deps.env ?? (deps.homedir ? { ...process.env, NOLO_HOME: join2(homedir(), ".nolo") } : process.env);
@@ -2255,13 +2584,43 @@ async function spawnLocalBackgroundRun(input, deps = {}) {
     }
   } catch {
   }
+  const executionRequest = input.localExecution;
+  if (executionRequest && (executionRequest.runtimeKey !== "local" || typeof executionRequest.readOnly !== "boolean" || typeof executionRequest.hostWritesAuthorized !== "boolean" || !executionRequest.readOnly && !executionRequest.hostWritesAuthorized)) {
+    throw new Error("Invalid authorized local execution facts");
+  }
+  const canonicalCwd = executionRequest ? String((fs.realpathSync ?? nodeFs2.realpathSync)(targetCwd)) : void 0;
+  const executionWorktree = canonicalCwd ? trustedLocalWorktree(canonicalCwd, resolvedDeps) : void 0;
+  const execution = executionRequest ? {
+    state: "known",
+    kind: "host-local",
+    runtimeKey: "local",
+    device: { kind: "localhost", hostname: nodeHostname(), platform: deps.platform ?? process.platform },
+    canonicalCwd,
+    ...executionWorktree ? { worktree: executionWorktree } : {},
+    permissions: {
+      hostWritesAuthorized: executionRequest.hostWritesAuthorized,
+      readOnly: executionRequest.readOnly,
+      ...executionRequest.allowedToolNames ? { allowedToolNames: [...executionRequest.allowedToolNames] } : {},
+      ...executionRequest.blockedToolNames ? { blockedToolNames: [...executionRequest.blockedToolNames] } : {}
+    },
+    provenance: executionRequest.provenance,
+    owner: { state: "unknown" }
+  } : { state: "unknown", reason: "missing-host-facts" };
   const title = normalizeRunTitle(input.title);
   const record = {
+    ...input.evidenceScope ? { evidenceScope: input.evidenceScope } : {},
+    ...input.dispatchSpeedProvenance ? { dispatchSpeedProvenance: input.dispatchSpeedProvenance } : {},
     runId,
     agentKey: input.agentKey,
-    ...typeof input.agentName === "string" && input.agentName.trim() ? { agentName: input.agentName.trim() } : {},
+    agentName: input.agentName?.trim() || shortAgentKey(input.agentKey),
     ...title ? { title } : {},
-    cwd: input.cwd,
+    cwd: canonicalCwd ?? input.cwd,
+    execution,
+    ...executionRequest ? { writerLaunch: { protocol: "fenced-launch-v1", attemptId: randomUUID2(), phase: "prepared" } } : {},
+    ...executionRequest ? (() => {
+      const parent = nativeOwner(process.pid, resolvedDeps);
+      return parent.state === "verified" ? { ownerPublication: { state: "pending", parent } } : {};
+    })() : {},
     ...messagePath ? { msgFile: messagePath } : input.msgFile ? { msgFile: input.msgFile } : {},
     startedAt: now().toISOString(),
     ...typeof input.timeoutMs === "number" ? { timeoutMs: input.timeoutMs } : {},
@@ -2269,6 +2628,7 @@ async function spawnLocalBackgroundRun(input, deps = {}) {
     logPath,
     queuePath,
     batchId,
+    ...input.selectionCheck ? { selectionCheck: input.selectionCheck } : {},
     ...typeof input.credentialGroup === "string" && input.credentialGroup.trim() ? { credentialGroup: input.credentialGroup.trim() } : {},
     ...typeof input.parentDialogId === "string" && input.parentDialogId.trim() ? { parentDialogId: input.parentDialogId.trim() } : {},
     ...typeof input.dialogId === "string" && input.dialogId.trim() ? { dialogId: input.dialogId.trim() } : {},
@@ -2293,8 +2653,12 @@ async function spawnLocalBackgroundRun(input, deps = {}) {
   const childEnv = {
     ...env,
     NOLO_AGENT_RUN_CHILD: "1",
-    NOLO_AGENT_RUN_ID: runId
+    NOLO_AGENT_RUN_ID: runId,
+    ...record.writerLaunch ? { NOLO_WRITER_LAUNCH_ATTEMPT: record.writerLaunch.attemptId } : {}
   };
+  if (!record.writerLaunch) delete childEnv.NOLO_WRITER_LAUNCH_ATTEMPT;
+  delete childEnv.NOLO_SUBTASK_MAX_TOOL_CALLS;
+  delete childEnv.NOLO_SUBTASK_MAX_WALL_CLOCK_MS;
   let hostMemory = null;
   let reservation;
   const logFd = fs.openSync(logPath, "a");
@@ -2308,6 +2672,8 @@ async function spawnLocalBackgroundRun(input, deps = {}) {
     ...fs.statSync ? { statSync: (path) => ({ mtimeMs: fs.statSync(path).mtimeMs }) } : {}
   };
   let proc;
+  let preparedScope;
+  const launchScope = (r) => JSON.stringify({ cwd: r.cwd, execution: r.execution, claim: r.localWriterClaim, publication: r.ownerPublication });
   try {
     reservation = reserveHostMemory({
       runsDir,
@@ -2319,8 +2685,14 @@ async function spawnLocalBackgroundRun(input, deps = {}) {
       getProcessStartTime: () => null,
       withLock: (id, fn, opts) => withRunRecordLock(id, resolvedDeps, fn, opts)
     });
+    const spawnCwd = input.claimLocalWrites ? acquireLocalWriterClaim(runId, input.cwd ?? process.cwd(), resolvedDeps) : canonicalCwd ?? input.cwd;
+    if (record.writerLaunch) {
+      const prepared = readRunRecord(runId, resolvedDeps);
+      if (!prepared || prepared.writerLaunch?.phase !== "prepared" || prepared.writerLaunch.attemptId !== record.writerLaunch.attemptId) throw new Error("[local-writer-resource] launch attempt revoked before spawn");
+      preparedScope = launchScope(prepared);
+    }
     proc = spawn(execPath, childArgs, {
-      cwd: input.cwd,
+      cwd: spawnCwd,
       env: childEnv,
       detached: true,
       // Detached on Windows means no console; hide the one its children would create.
@@ -2330,6 +2702,7 @@ async function spawnLocalBackgroundRun(input, deps = {}) {
   } catch (error) {
     try {
       reservation?.release("spawn_sync_failed");
+      if (input.claimLocalWrites) releaseUnspawnedLocalWriterClaim(runId, resolvedDeps);
     } finally {
       finalizeRunRecord(runId, { status: "failed", exitCode: 1, note: String(error) }, resolvedDeps);
     }
@@ -2352,13 +2725,56 @@ async function spawnLocalBackgroundRun(input, deps = {}) {
   });
   const hostMemoryNotice = emitHostMemoryNotice(hostMemory, input.output);
   if (typeof proc.pid === "number") {
-    withRunRecordLock(runId, resolvedDeps, () => {
-      const latest = readRunRecord(runId, resolvedDeps) ?? record;
+    const nativeStartedAt = executionRequest ? probeProcessStartTime(proc.pid, resolvedDeps) : null;
+    let linuxIdentity;
+    if (executionRequest && (deps.platform ?? process.platform) === "linux") {
+      try {
+        const stat = String(nodeFs2.readFileSync(`/proc/${proc.pid}/stat`, "utf8"));
+        const startTicks = stat.slice(stat.lastIndexOf(")") + 2).split(/\s+/)[19];
+        const bootId = nodeFs2.readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim();
+        if (/^\d+$/.test(startTicks) && bootId) linuxIdentity = { bootId, startTicks };
+      } catch {
+      }
+    }
+    const confirmedStart = executionRequest ? probeProcessStartTime(proc.pid, resolvedDeps) : null;
+    const stableNativeIdentity = nativeStartedAt && confirmedStart && nativeStartedAt.getTime() === confirmedStart.getTime() && !isPidGone(proc.pid, resolvedDeps);
+    const publishOwner = () => withRunRecordLock(runId, resolvedDeps, () => {
+      const latest = readRunRecord(runId, resolvedDeps);
+      if (!latest) throw new Error("[local-writer-resource] publication record missing");
+      if (record.writerLaunch) {
+        const launch = latest.writerLaunch;
+        if (launch?.protocol !== "fenced-launch-v1" || launch.attemptId !== record.writerLaunch.attemptId || launch.phase !== "prepared") {
+          throw new Error("[local-writer-resource] publication attempt revoked/mismatched");
+        }
+        if (launchScope(latest) !== preparedScope) throw new Error("[local-writer-resource] publication scope changed");
+      }
       latest.pid = proc.pid;
-      latest.processIdentity ??= "unverified";
+      if (latest.execution?.state === "known") {
+        const verified = stableNativeIdentity && ((deps.platform ?? process.platform) !== "linux" || linuxIdentity);
+        latest.execution.owner = verified ? {
+          state: "verified",
+          pid: proc.pid,
+          startedAt: nativeStartedAt.toISOString(),
+          source: "parent-native",
+          ...linuxIdentity ? { linux: linuxIdentity } : {}
+        } : { state: "unknown" };
+        latest.processIdentity = verified ? "verified" : "unverified";
+        latest.processStartedAt = verified ? nativeStartedAt.toISOString() : void 0;
+      } else {
+        latest.processIdentity ??= "unverified";
+      }
+      if (latest.writerLaunch && latest.execution?.state === "known" && latest.execution.owner.state === "verified") {
+        latest.writerLaunch.phase = "granted";
+      }
+      if (latest.ownerPublication) latest.ownerPublication.state = "complete";
       writeRunRecord(latest, resolvedDeps);
       return true;
-    }, { strict: true });
+    }, { strict: true, requireDeadOwner: true });
+    const publicationDeadline = Date.now() + 2e3;
+    while (!publishOwner()) {
+      if (Date.now() >= publicationDeadline) throw new Error("[local-writer-resource] parent owner publication lock busy");
+      await new Promise((resolve2) => setTimeout(resolve2, 20));
+    }
     try {
       const persisted = readRunRecord(runId, resolvedDeps);
       reservation.associate({ runId, pid: proc.pid, processStartedAt: persisted?.processStartedAt });
@@ -2383,6 +2799,8 @@ async function spawnLocalBackgroundRun(input, deps = {}) {
     logPath,
     queuePath,
     batchId,
+    agentName: record.agentName ?? shortAgentKey(input.agentKey),
+    ...input.selectionCheck ? { selectionCheck: input.selectionCheck } : {},
     ...hostMemoryNotice ? { hostMemoryNotice } : {}
   };
 }
@@ -2491,8 +2909,31 @@ function transitionRunToTerminal(runId, update, deps = {}, options = {}) {
     if (typeof update.lastAssistantText === "string" && update.lastAssistantText) {
       record2.lastAssistantText = update.lastAssistantText.slice(0, 2e3);
     }
+    if (update.cacheUsage) {
+      record2.cacheHitRatio = update.cacheUsage.cache_hit_ratio;
+      record2.cacheCachedTokens = update.cacheUsage.cached_tokens;
+    }
     record2.endedAt = now().toISOString();
-    if (typeof update.lastAssistantText === "string" && update.lastAssistantText) {
+    let resultWriteFailed = false;
+    let pendingResultFile;
+    let stagingComplete = false;
+    let backupFile;
+    let backupVerified = false;
+    const registerArtifact = (path, kind) => {
+      const fs = deps.fs ?? nodeFs2;
+      const stat = fs.lstatSync?.(path);
+      if (!stat || !stat.isFile() || stat.isSymbolicLink()) return;
+      const artifact = {
+        publisher: "run-result-v1",
+        path,
+        kind,
+        dev: String(stat.dev),
+        ino: String(stat.ino),
+        sha256: createHash("sha256").update(fs.readFileSync(path)).digest("hex")
+      };
+      record2.resultArtifacts = [...(record2.resultArtifacts ?? []).filter((a) => a.path !== path), artifact];
+    };
+    if (typeof update.lastAssistantText === "string" && update.lastAssistantText || update.acceptance?.checks.observations?.length) {
       try {
         const fs = deps.fs ?? nodeFs2;
         const resultFile = join2(resolveRunsDir(deps.env, deps.homedir), `${runId}.result.md`);
@@ -2501,6 +2942,7 @@ function transitionRunToTerminal(runId, update, deps = {}, options = {}) {
         const content = buildResultFileContent(
           {
             runId,
+            acceptance: update.acceptance,
             status: record2.status,
             agentName: record2.agentName,
             model: update.model,
@@ -2515,16 +2957,54 @@ function transitionRunToTerminal(runId, update, deps = {}, options = {}) {
             continuedFrom: record2.continuedFrom,
             ...update.cacheUsage ? { cacheUsage: update.cacheUsage } : {}
           },
-          update.lastAssistantText
+          update.lastAssistantText ?? ""
         );
-        fs.writeFileSync(resultFile, content, "utf8");
+        if (typeof fs.renameSync !== "function") throw new Error("atomic result publication requires renameSync");
+        pendingResultFile = `${resultFile}.${randomUUID2()}.pending`;
+        try {
+          fs.writeFileSync(pendingResultFile, content, { encoding: "utf8", flag: "wx" });
+          stagingComplete = true;
+        } finally {
+          if (fs.existsSync(pendingResultFile)) registerArtifact(pendingResultFile, "pending");
+        }
+        if (fs.existsSync(resultFile)) {
+          const previous = fs.readFileSync(resultFile);
+          const backup = `${resultFile}.${randomUUID2()}.bak`;
+          backupFile = backup;
+          try {
+            fs.writeFileSync(backup, previous, { flag: "wx" });
+          } finally {
+            if (fs.existsSync(backup)) registerArtifact(backup, "bak");
+          }
+          const sameBytes = (a, b) => Buffer.from(a).equals(Buffer.from(b));
+          if (!sameBytes(previous, fs.readFileSync(backup)) || !sameBytes(previous, fs.readFileSync(resultFile))) {
+            throw new Error("previous result backup verification failed");
+          }
+          backupVerified = true;
+        }
+        fs.renameSync(pendingResultFile, resultFile);
+        record2.resultArtifacts = record2.resultArtifacts?.filter((a) => a.path !== pendingResultFile);
+        pendingResultFile = void 0;
         record2.resultFile = resultFile;
       } catch {
+        resultWriteFailed = true;
+        delete record2.resultFile;
+        if (record2.status === "done") {
+          record2.status = "failed";
+          record2.exitCode = 1;
+        }
       }
     }
     if (typeof update.note === "string" && update.note.trim()) {
       record2.note = update.note.trim();
     }
+    if (resultWriteFailed) {
+      if (record2.note?.startsWith("orphaned:")) record2.note = void 0;
+      const fs = deps.fs ?? nodeFs2;
+      const stagingNote = pendingResultFile ? fs.existsSync(pendingResultFile) ? `${stagingComplete ? "complete staging copy" : "incomplete staging fragment"}: ${pendingResultFile}` : `staging not created: ${pendingResultFile}` : "staging not created";
+      const backupNote = backupFile ? `${fs.existsSync(backupFile) ? backupVerified ? "full verified backup" : "partial backup" : "backup not created"}: ${backupFile}` : "backup not created";
+      record2.note = [record2.note, `result file write failed; complete final report was not saved; ${stagingNote}; ${backupNote}`].filter(Boolean).join("; ");
+    }
     if (record2.note?.startsWith("orphaned:")) record2.note = void 0;
     writeRunRecord(record2, deps);
     return { kind: "transitioned", record: record2 };
@@ -2600,10 +3080,10 @@ function defaultGetProcessStartTime(pid, deps = {}) {
       // 这会让 isPidReused 的结论依赖调用者环境：同一条 run 记录在英文
       // locale 下被判 pid reused → orphaned，中文 locale 下不判。强制 C
       // locale 让输出恒为可解析的英文格式，结果与 locale 无关。
-      env: { ...process.env, LC_ALL: "C", LANG: "C" }
+      env: { ...process.env, LC_ALL: "C", LANG: "C", TZ: "UTC" }
     }).trim();
     if (!output) return null;
-    const d = new Date(output);
+    const d = new Date(output.endsWith("Z") || /[+-]\d\d:\d\d$/.test(output) ? output : `${output} UTC`);
     return isNaN(d.getTime()) ? null : d;
   } catch {
     return null;
@@ -2655,6 +3135,7 @@ function checkStaleRun(runId, deps = {}) {
     const latest = readRunRecord(runId, deps);
     if (!latest) return record;
     if (latest.status !== "running") return latest;
+    if (latest.pid !== record.pid || latest.processStartedAt !== record.processStartedAt || latest.processIdentity !== record.processIdentity) return latest;
     if (latest.activity?.updatedAt !== record.activity?.updatedAt) return latest;
     const at = now().toISOString();
     latest.status = "orphaned";
@@ -2670,6 +3151,16 @@ function checkStaleRun(runId, deps = {}) {
     }
     latest.endedAt = at;
     latest.reconciledAt = at;
+    if ((pidGone || pidReused) && latest.localWriterClaim?.state === "held") {
+      latest.localWriterClaim.state = "released";
+    }
+    latest.ownerDeath = {
+      pid: latest.pid,
+      processStartedAt: latest.processStartedAt,
+      processIdentity: latest.processIdentity,
+      ...latest.execution?.state === "known" ? { executionOwner: latest.execution.owner } : {},
+      confirmedAt: at
+    };
     latest.pid = void 0;
     writeRunRecord(latest, deps);
     return latest;
@@ -2840,6 +3331,7 @@ async function runAgentStatusCommand(args, deps) {
     const { partialCheckpoint, ...summary } = record;
     deps.output.write(JSON.stringify({
       ...summary,
+      ...localWriterRecovery(record) ? { writerRecovery: localWriterRecovery(record) } : {},
       ...includeCheckpoint ? { checkpoint: partialCheckpoint ? { ...partialCheckpoint, available: true } : { available: false, final: false, reason: "checkpoint_missing" } } : {}
     }) + "\n");
     return 0;
@@ -2874,6 +3366,9 @@ function printStatusOnce(record, deps) {
   deps.output.write(`status:   ${record.status}
 `);
   deps.output.write(`pid:      ${record.pid ?? "-"}
+`);
+  const recovery = localWriterRecovery(record);
+  if (recovery) deps.output.write(`writerRecovery: required (${recovery.reason}); automatic release forbidden; native launch evidence required
 `);
   deps.output.write(`agent:    ${record.agentKey}
 `);
@@ -3131,16 +3626,28 @@ async function runAgentStopCommand(args, deps) {
 async function runAgentKillCommand(args, deps) {
   return runSignalCommand(args, "SIGKILL", "kill", deps);
 }
+async function runAgentRecoverPreparedWriterCommand(args, deps) {
+  if (args.length !== 3 || args[1] !== "--attempt-id" || !/^[A-Za-z0-9_-]+$/.test(args[0] ?? "") || !args[2] || args[2].startsWith("-")) {
+    deps.output.write("Usage: nolo agent recover-prepared-writer <runId> --attempt-id <attemptId>\n");
+    return 1;
+  }
+  const [runId, , attemptId] = args;
+  const outcome = revokePreparedWriterLaunch(runId, attemptId, deps);
+  deps.output.write(JSON.stringify({ action: "recoverPreparedWriter", runId, attemptId, outcome }) + "\n");
+  return outcome === "blocked" ? 1 : 0;
+}
 
 export {
-  TAIL_LINES_MAX,
   createShellApprovalChild,
+  TAIL_LINES_MAX,
   readHostMemory,
   assertHostMemoryAdmission,
   resolveResultServerMeta,
   recordRunResultHeaderMeta,
   getRunResultHeaderMeta,
   serverOriginForDialog,
+  stripResultFrontMatter,
+  isHistoryIntegrityFailure,
   RUN_TERMINAL_STATUSES,
   isRunTerminalStatus,
   resolveNoloHome,
@@ -3188,6 +3695,12 @@ export {
   absolutizeSkillArgs,
   rewriteMsgFileArg,
   buildAgentRunChildCommand,
+  localWriterRecovery,
+  revokePreparedWriterLaunch,
+  validateLocalWriterChild,
+  awaitLocalWriterChild,
+  resolveLocalContinuation,
+  registerLocalForegroundWriter,
   spawnLocalBackgroundRun,
   ackRunRecord,
   DEFAULT_ACK_LEASE_TTL_MS,
@@ -3215,5 +3728,6 @@ export {
   TERMINATE_KILL_GRACE_MS,
   terminateRunProcess,
   runAgentStopCommand,
-  runAgentKillCommand
+  runAgentKillCommand,
+  runAgentRecoverPreparedWriterCommand
 };