chainlesschain 0.162.187 → 0.162.189

package/src/lib/secure-file-identity.js

@@ -0,0 +1,433 @@
+/**
+ * Cross-API filesystem identity checks for secure path reads.
+ *
+ * Node 22.12 ships libuv 1.49.1. On Windows hosts that expose
+ * GetFileInformationByName, libuv 1.49/1.50 can project a path stat's device as
+ * zero while fstat on the same opened file reports the real volume serial.
+ * libuv 1.51 fixed the structure layout and device projection.
+ *
+ * Keep this compatibility deliberately narrow: only the affected Windows
+ * libuv range may ignore the path API's projected device, the handle device
+ * must match a separately opened parent/volume-root directory handle, and
+ * every other identity or mutation field remains exact.
+ *
+ * Holding a parent descriptor does not give Node's path-based fs APIs openat
+ * semantics. Callers must keep the canonical parent authority outside the
+ * control of untrusted concurrent writers. The checks below detect ordinary
+ * path/handle replacement, but a complete rename-away/replace/restore ABA can
+ * happen between checks and is deliberately not represented as prevented.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+
+const IDENTITY_FIELDS = Object.freeze([
+  "dev",
+  "ino",
+  "mode",
+  "nlink",
+  "size",
+  "mtimeNs",
+  "ctimeNs",
+]);
+const IDENTITY_FIELDS_EXCEPT_DEVICE = Object.freeze(
+  IDENTITY_FIELDS.filter((field) => field !== "dev"),
+);
+const DIRECTORY_IDENTITY_FIELDS = Object.freeze(["dev", "ino", "mode"]);
+const DIRECTORY_IDENTITY_FIELDS_EXCEPT_DEVICE = Object.freeze(
+  DIRECTORY_IDENTITY_FIELDS.filter((field) => field !== "dev"),
+);
+
+export const SECURE_FILE_IDENTITY_ERROR = Object.freeze({
+  INVALID_PARENT: "SECURE_FILE_IDENTITY_INVALID_PARENT",
+  PARENT_RACE: "SECURE_FILE_IDENTITY_PARENT_RACE",
+});
+
+export class SecureFileIdentityError extends Error {
+  constructor(code, message, details = {}, cause = null) {
+    super(message, cause ? { cause } : undefined);
+    this.name = "SecureFileIdentityError";
+    this.code = code;
+    Object.assign(this, details);
+  }
+}
+
+function identityError(code, message, details = {}, cause = null) {
+  return new SecureFileIdentityError(code, message, details, cause);
+}
+
+function timestampValue(stat, nanosecondsKey, millisecondsKey) {
+  if (stat?.[nanosecondsKey] !== undefined && stat?.[nanosecondsKey] !== null) {
+    return String(stat[nanosecondsKey]);
+  }
+  if (stat?.[millisecondsKey] !== undefined) {
+    const value = Number(stat[millisecondsKey]);
+    return Number.isFinite(value)
+      ? String(Math.trunc(value * 1_000_000))
+      : null;
+  }
+  return null;
+}
+
+function scalarValue(stat, field) {
+  return stat?.[field] === undefined || stat?.[field] === null
+    ? null
+    : String(stat[field]);
+}
+
+/**
+ * Normalize either an fs.Stats/fs.BigIntStats object or an already normalized
+ * identity. Nanosecond fields are preferred so BigInt stat callers retain the
+ * exact timestamps returned by the kernel.
+ */
+export function fileStatIdentity(stat) {
+  return {
+    dev: scalarValue(stat, "dev"),
+    ino: scalarValue(stat, "ino"),
+    mode: scalarValue(stat, "mode"),
+    nlink: scalarValue(stat, "nlink"),
+    size: scalarValue(stat, "size"),
+    mtimeNs: timestampValue(stat, "mtimeNs", "mtimeMs"),
+    ctimeNs: timestampValue(stat, "ctimeNs", "ctimeMs"),
+  };
+}
+
+function hasCompleteIdentity(identity) {
+  return IDENTITY_FIELDS.every((field) => identity[field] !== null);
+}
+
+function hasFields(identity, fields) {
+  return fields.every((field) => identity[field] !== null);
+}
+
+function sameFields(left, right, fields) {
+  return fields.every((field) => left[field] === right[field]);
+}
+
+function runtimePlatform(runtime) {
+  return String(runtime?.platform || process.platform);
+}
+
+function windowsVolumeOrShareRoot(canonicalPath) {
+  const normalized = path.win32.normalize(String(canonicalPath));
+  const extendedUnc = /^\\\\\?\\UNC\\([^\\]+)\\([^\\]+)(?:\\|$)/iu.exec(
+    normalized,
+  );
+  if (extendedUnc) {
+    return `\\\\?\\UNC\\${extendedUnc[1]}\\${extendedUnc[2]}\\`;
+  }
+  return path.win32.parse(normalized).root || path.parse(normalized).root;
+}
+
+export function sameFileStatIdentity(leftStat, rightStat) {
+  const left = fileStatIdentity(leftStat);
+  const right = fileStatIdentity(rightStat);
+  return (
+    hasCompleteIdentity(left) &&
+    hasCompleteIdentity(right) &&
+    sameFields(left, right, IDENTITY_FIELDS)
+  );
+}
+
+export function sameDirectoryStatIdentity(leftStat, rightStat) {
+  const left = fileStatIdentity(leftStat);
+  const right = fileStatIdentity(rightStat);
+  return (
+    hasFields(left, DIRECTORY_IDENTITY_FIELDS) &&
+    hasFields(right, DIRECTORY_IDENTITY_FIELDS) &&
+    sameFields(left, right, DIRECTORY_IDENTITY_FIELDS)
+  );
+}
+
+export function isAffectedWindowsZeroDeviceStatRuntime({
+  platform = process.platform,
+  uvVersion = process.versions.uv,
+} = {}) {
+  if (platform !== "win32") return false;
+  const match = /^(\d+)\.(\d+)(?:\.|$)/.exec(String(uvVersion || ""));
+  if (!match) return false;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  return major === 1 && (minor === 49 || minor === 50);
+}
+
+/**
+ * Compare a path stat with an opened-handle stat (or a previously normalized
+ * handle identity) while binding the file to a trusted directory device.
+ */
+export function samePathHandleFileIdentity(
+  pathStat,
+  handleStat,
+  expectedDevice,
+  runtime = undefined,
+) {
+  const pathIdentity = fileStatIdentity(pathStat);
+  const handleIdentity = fileStatIdentity(handleStat);
+  const trustedDevice =
+    expectedDevice === undefined || expectedDevice === null
+      ? null
+      : String(expectedDevice);
+  if (
+    !hasCompleteIdentity(pathIdentity) ||
+    !hasCompleteIdentity(handleIdentity) ||
+    trustedDevice === null ||
+    handleIdentity.dev !== trustedDevice
+  ) {
+    return false;
+  }
+  if (sameFields(pathIdentity, handleIdentity, IDENTITY_FIELDS)) return true;
+  return (
+    isAffectedWindowsZeroDeviceStatRuntime(runtime) &&
+    pathIdentity.dev !== handleIdentity.dev &&
+    handleIdentity.dev !== "0" &&
+    sameFields(pathIdentity, handleIdentity, IDENTITY_FIELDS_EXCEPT_DEVICE)
+  );
+}
+
+/**
+ * Directory contents can legitimately change while a child is written, so a
+ * parent recheck excludes content-derived metadata and the directory link
+ * count, retaining only stable identity/type/permission fields.
+ */
+export function samePathHandleDirectoryIdentity(
+  pathStat,
+  handleStat,
+  expectedDevice,
+  runtime = undefined,
+) {
+  const pathIdentity = fileStatIdentity(pathStat);
+  const handleIdentity = fileStatIdentity(handleStat);
+  const trustedDevice =
+    expectedDevice === undefined || expectedDevice === null
+      ? null
+      : String(expectedDevice);
+  if (
+    !hasFields(pathIdentity, DIRECTORY_IDENTITY_FIELDS) ||
+    !hasFields(handleIdentity, DIRECTORY_IDENTITY_FIELDS) ||
+    trustedDevice === null ||
+    handleIdentity.dev !== trustedDevice
+  ) {
+    return false;
+  }
+  if (sameDirectoryStatIdentity(pathIdentity, handleIdentity)) {
+    return true;
+  }
+  return (
+    isAffectedWindowsZeroDeviceStatRuntime(runtime) &&
+    pathIdentity.dev !== handleIdentity.dev &&
+    handleIdentity.dev !== "0" &&
+    sameFields(
+      pathIdentity,
+      handleIdentity,
+      DIRECTORY_IDENTITY_FIELDS_EXCEPT_DEVICE,
+    )
+  );
+}
+
+function canonicalRealpath(runtimeFs, target) {
+  const realpathSync = runtimeFs?.realpathSync;
+  if (typeof realpathSync?.native === "function") {
+    return realpathSync.native(target);
+  }
+  if (typeof realpathSync === "function") {
+    return realpathSync.call(runtimeFs, target);
+  }
+  throw new TypeError("runtime fs does not provide realpathSync");
+}
+
+/**
+ * Open and retain the canonical parent directory while a caller inspects and
+ * opens a child. On Windows, a separately opened canonical volume/share root
+ * supplies the independently trusted device used by the identity comparators.
+ *
+ * Security precondition: the caller must ensure that an untrusted concurrent
+ * writer cannot rename the canonical parent (or one of its ancestors) during
+ * the callback. Node does not expose the handle-relative open/rename primitives
+ * required to make this helper an openat-style authority boundary.
+ */
+export function withTrustedFileParentSync(
+  runtimeFs,
+  filePath,
+  callback,
+  { runtime = undefined } = {},
+) {
+  if (!runtimeFs || typeof callback !== "function") {
+    throw new TypeError("runtime fs and callback are required");
+  }
+  if (callback.constructor?.name === "AsyncFunction") {
+    throw new TypeError("secure file parent callback must be synchronous");
+  }
+  const requested = path.resolve(filePath);
+  const requestedParent = path.dirname(requested);
+  let canonicalParent;
+  try {
+    canonicalParent = canonicalRealpath(runtimeFs, requestedParent);
+  } catch (cause) {
+    throw identityError(
+      SECURE_FILE_IDENTITY_ERROR.INVALID_PARENT,
+      `Could not canonicalize secure file parent: ${requestedParent}`,
+      { filePath: requested, parentPath: requestedParent },
+      cause,
+    );
+  }
+
+  let authorityDescriptor = null;
+  let descriptor = null;
+  try {
+    const flags =
+      Number(runtimeFs.constants?.O_RDONLY ?? fs.constants.O_RDONLY) |
+      Number(runtimeFs.constants?.O_NOFOLLOW ?? fs.constants.O_NOFOLLOW ?? 0);
+    let trustedDevice = null;
+    if (runtimePlatform(runtime) === "win32") {
+      const authorityPath = windowsVolumeOrShareRoot(canonicalParent);
+      if (!authorityPath) {
+        throw identityError(
+          SECURE_FILE_IDENTITY_ERROR.INVALID_PARENT,
+          `Could not identify secure file parent volume/share root: ${canonicalParent}`,
+          { filePath: requested, parentPath: canonicalParent },
+        );
+      }
+      try {
+        authorityDescriptor = runtimeFs.openSync(authorityPath, flags);
+        const authority = runtimeFs.fstatSync(authorityDescriptor, {
+          bigint: true,
+        });
+        if (!authority.isDirectory() || String(authority.dev) === "0") {
+          throw identityError(
+            SECURE_FILE_IDENTITY_ERROR.INVALID_PARENT,
+            `Secure file parent volume/share root is not a stable directory: ${authorityPath}`,
+            {
+              filePath: requested,
+              parentPath: canonicalParent,
+              authorityPath,
+            },
+          );
+        }
+        trustedDevice = String(authority.dev);
+      } catch (cause) {
+        if (cause instanceof SecureFileIdentityError) throw cause;
+        throw identityError(
+          SECURE_FILE_IDENTITY_ERROR.INVALID_PARENT,
+          `Could not open secure file parent volume/share root: ${authorityPath}`,
+          {
+            filePath: requested,
+            parentPath: canonicalParent,
+            authorityPath,
+          },
+          cause,
+        );
+      }
+    }
+
+    let before;
+    try {
+      before = runtimeFs.lstatSync(canonicalParent, { bigint: true });
+    } catch (cause) {
+      throw identityError(
+        SECURE_FILE_IDENTITY_ERROR.INVALID_PARENT,
+        `Could not inspect secure file parent: ${canonicalParent}`,
+        { filePath: requested, parentPath: canonicalParent },
+        cause,
+      );
+    }
+    if (before.isSymbolicLink() || !before.isDirectory()) {
+      throw identityError(
+        SECURE_FILE_IDENTITY_ERROR.INVALID_PARENT,
+        `Secure file parent must be a real directory: ${canonicalParent}`,
+        { filePath: requested, parentPath: canonicalParent },
+      );
+    }
+    if (trustedDevice === null) {
+      trustedDevice = scalarValue(before, "dev");
+    }
+
+    descriptor = runtimeFs.openSync(canonicalParent, flags);
+    const opened = runtimeFs.fstatSync(descriptor, { bigint: true });
+    if (
+      !opened.isDirectory() ||
+      !samePathHandleDirectoryIdentity(before, opened, trustedDevice, runtime)
+    ) {
+      throw identityError(
+        SECURE_FILE_IDENTITY_ERROR.PARENT_RACE,
+        `Secure file parent changed while opening: ${canonicalParent}`,
+        { filePath: requested, parentPath: canonicalParent },
+      );
+    }
+    let result;
+    let callbackFailure = null;
+    try {
+      result = callback({
+        canonicalPath: path.join(canonicalParent, path.basename(requested)),
+        parentPath: canonicalParent,
+        parentDevice: String(opened.dev),
+        parentDescriptor: descriptor,
+      });
+      if (result && typeof result.then === "function") {
+        callbackFailure = new TypeError(
+          "secure file parent callback must not return a promise",
+        );
+      }
+    } catch (cause) {
+      callbackFailure = cause;
+    }
+
+    let heldAfter;
+    try {
+      heldAfter = runtimeFs.fstatSync(descriptor, { bigint: true });
+    } catch (cause) {
+      throw identityError(
+        SECURE_FILE_IDENTITY_ERROR.PARENT_RACE,
+        `Secure file parent handle became unavailable: ${canonicalParent}`,
+        { filePath: requested, parentPath: canonicalParent },
+        cause,
+      );
+    }
+    if (
+      !heldAfter.isDirectory() ||
+      !sameDirectoryStatIdentity(heldAfter, opened)
+    ) {
+      throw identityError(
+        SECURE_FILE_IDENTITY_ERROR.PARENT_RACE,
+        `Secure file parent handle changed during operation: ${canonicalParent}`,
+        { filePath: requested, parentPath: canonicalParent },
+        callbackFailure,
+      );
+    }
+
+    let after;
+    try {
+      after = runtimeFs.lstatSync(canonicalParent, { bigint: true });
+    } catch (cause) {
+      throw identityError(
+        SECURE_FILE_IDENTITY_ERROR.PARENT_RACE,
+        `Secure file parent became unavailable: ${canonicalParent}`,
+        { filePath: requested, parentPath: canonicalParent },
+        cause,
+      );
+    }
+    if (
+      after.isSymbolicLink() ||
+      !after.isDirectory() ||
+      !samePathHandleDirectoryIdentity(after, heldAfter, opened.dev, runtime)
+    ) {
+      throw identityError(
+        SECURE_FILE_IDENTITY_ERROR.PARENT_RACE,
+        `Secure file parent changed during operation: ${canonicalParent}`,
+        { filePath: requested, parentPath: canonicalParent },
+        callbackFailure,
+      );
+    }
+    if (callbackFailure) throw callbackFailure;
+    return result;
+  } finally {
+    try {
+      if (descriptor !== null) {
+        runtimeFs.closeSync(descriptor);
+      }
+    } finally {
+      if (authorityDescriptor !== null) {
+        runtimeFs.closeSync(authorityDescriptor);
+      }
+    }
+  }
+}

package/src/lib/turn-binding.js

@@ -69,6 +69,20 @@ export function classifyToolKind(name) {
  *   mutation WITHOUT a checkpoint                        → NONE (files unrecoverable)
  */
 export function computeCoverage(flags = {}) {
+  const managedCoverage =
+    flags.managedCheckpointCoverage === TURN_COVERAGE.FULL ||
+    flags.managedCheckpointCoverage === TURN_COVERAGE.PARTIAL ||
+    flags.managedCheckpointCoverage === TURN_COVERAGE.NONE
+      ? flags.managedCheckpointCoverage
+      : null;
+  // An explicit managed-checkpoint verdict is stronger than the legacy
+  // tool-name heuristic. `none` means the requested writer lifetime could not
+  // be bounded; `partial` means workspace recovery exists but at least one
+  // path/effect remains outside it.
+  if (managedCoverage === TURN_COVERAGE.NONE) return TURN_COVERAGE.NONE;
+  if (managedCoverage === TURN_COVERAGE.PARTIAL) {
+    return TURN_COVERAGE.PARTIAL;
+  }
   const sideEffects = Boolean(
     flags.ranShell ||
     flags.spawnedExternalProcess ||
@@ -76,10 +90,23 @@ export function computeCoverage(flags = {}) {
   );
   if (sideEffects) return TURN_COVERAGE.PARTIAL;
   if (!flags.mutatedFiles) return TURN_COVERAGE.FULL;
-  if (flags.hasFileCheckpoint) return TURN_COVERAGE.FULL;
+  if (managedCoverage === TURN_COVERAGE.FULL || flags.hasFileCheckpoint) {
+    return TURN_COVERAGE.FULL;
+  }
   return TURN_COVERAGE.NONE;
 }
 
+function mergeManagedCoverage(current, next) {
+  const rank = {
+    [TURN_COVERAGE.FULL]: 2,
+    [TURN_COVERAGE.PARTIAL]: 1,
+    [TURN_COVERAGE.NONE]: 0,
+  };
+  if (!(next in rank)) return current ?? null;
+  if (!(current in rank)) return next;
+  return rank[next] < rank[current] ? next : current;
+}
+
 function emptyRecord(turnId, conversationOffset) {
   return {
     turnId,
@@ -92,6 +119,7 @@ function emptyRecord(turnId, conversationOffset) {
     permissionDecisionIds: [],
     childAgentIds: [],
     childBindings: [],
+    managedCheckpoints: [],
     worktreeId: null,
     // side-effect flags → coverage (kept internal; surfaced via `coverage`)
     _flags: {
@@ -100,6 +128,7 @@ function emptyRecord(turnId, conversationOffset) {
       userEditedDuringTurn: false,
       mutatedFiles: false,
       hasFileCheckpoint: false,
+      managedCheckpointCoverage: null,
     },
   };
 }
@@ -206,6 +235,62 @@ export class TurnBindingLog {
     return this;
   }
 
+  /**
+   * Bind durable Process Broker workspace-transaction evidence without
+   * overloading `fileCheckpointId` (which belongs to the legacy git rewind
+   * engine). Multiple tool calls may settle in one turn, so the worst coverage
+   * verdict governs the turn.
+   */
+  recordManagedCheckpoint(turnId, checkpoint = {}) {
+    const coverage =
+      checkpoint.coverage === TURN_COVERAGE.FULL ||
+      checkpoint.coverage === TURN_COVERAGE.PARTIAL ||
+      checkpoint.coverage === TURN_COVERAGE.NONE
+        ? checkpoint.coverage
+        : TURN_COVERAGE.NONE;
+    const normalized = {
+      toolUseId:
+        checkpoint.toolUseId == null ? null : String(checkpoint.toolUseId),
+      tool: checkpoint.tool == null ? null : String(checkpoint.tool),
+      transactionId:
+        checkpoint.transactionId == null
+          ? null
+          : String(checkpoint.transactionId),
+      checkpointId:
+        checkpoint.checkpointId == null
+          ? null
+          : String(checkpoint.checkpointId),
+      evidenceDigest:
+        checkpoint.evidenceDigest == null
+          ? null
+          : String(checkpoint.evidenceDigest),
+      phase: checkpoint.phase == null ? null : String(checkpoint.phase),
+      coverage,
+      fileCoverage:
+        checkpoint.fileCoverage === TURN_COVERAGE.FULL ||
+        checkpoint.fileCoverage === TURN_COVERAGE.PARTIAL ||
+        checkpoint.fileCoverage === TURN_COVERAGE.NONE
+          ? checkpoint.fileCoverage
+          : TURN_COVERAGE.NONE,
+    };
+    const rec = this._rec(turnId);
+    const existingIndex = rec.managedCheckpoints.findIndex(
+      (item) =>
+        (normalized.transactionId &&
+          item.transactionId === normalized.transactionId) ||
+        (!normalized.transactionId &&
+          normalized.toolUseId &&
+          item.toolUseId === normalized.toolUseId),
+    );
+    if (existingIndex === -1) rec.managedCheckpoints.push(normalized);
+    else rec.managedCheckpoints[existingIndex] = normalized;
+    rec._flags.managedCheckpointCoverage = mergeManagedCoverage(
+      rec._flags.managedCheckpointCoverage,
+      coverage,
+    );
+    return this;
+  }
+
   setWorktree(turnId, worktreeId) {
     this._rec(turnId).worktreeId =
       worktreeId == null ? null : String(worktreeId);
@@ -271,6 +356,13 @@ export class TurnBindingLog {
         checkpointIds: [...binding.checkpointIds],
         toolUseIds: [...binding.toolUseIds],
       })),
+      ...(rec.managedCheckpoints.length > 0
+        ? {
+            managedCheckpoints: rec.managedCheckpoints.map((checkpoint) => ({
+              ...checkpoint,
+            })),
+          }
+        : {}),
       worktreeId: rec.worktreeId,
       coverage: computeCoverage(rec._flags),
     };
@@ -280,7 +372,13 @@ export class TurnBindingLog {
     return {
       turns: this._order.map((id) => {
         const r = this._turns.get(id);
-        return { ...r, _flags: { ...r._flags } };
+        return {
+          ...r,
+          managedCheckpoints: r.managedCheckpoints.map((checkpoint) => ({
+            ...checkpoint,
+          })),
+          _flags: { ...r._flags },
+        };
       }),
     };
   }
@@ -316,6 +414,39 @@ export class TurnBindingLog {
               worktreePath: binding.worktreePath ?? null,
             }))
           : [],
+        managedCheckpoints: Array.isArray(r.managedCheckpoints)
+          ? r.managedCheckpoints.map((checkpoint) => ({
+              toolUseId:
+                checkpoint?.toolUseId == null
+                  ? null
+                  : String(checkpoint.toolUseId),
+              tool: checkpoint?.tool == null ? null : String(checkpoint.tool),
+              transactionId:
+                checkpoint?.transactionId == null
+                  ? null
+                  : String(checkpoint.transactionId),
+              checkpointId:
+                checkpoint?.checkpointId == null
+                  ? null
+                  : String(checkpoint.checkpointId),
+              evidenceDigest:
+                checkpoint?.evidenceDigest == null
+                  ? null
+                  : String(checkpoint.evidenceDigest),
+              phase:
+                checkpoint?.phase == null ? null : String(checkpoint.phase),
+              coverage:
+                checkpoint?.coverage === TURN_COVERAGE.FULL ||
+                checkpoint?.coverage === TURN_COVERAGE.PARTIAL
+                  ? checkpoint.coverage
+                  : TURN_COVERAGE.NONE,
+              fileCoverage:
+                checkpoint?.fileCoverage === TURN_COVERAGE.FULL ||
+                checkpoint?.fileCoverage === TURN_COVERAGE.PARTIAL
+                  ? checkpoint.fileCoverage
+                  : TURN_COVERAGE.NONE,
+            }))
+          : [],
         worktreeId: r.worktreeId ?? null,
         _flags: { ...emptyRecord(id)._flags, ...(r._flags || {}) },
       });
@@ -537,6 +668,33 @@ export function createTurnBindingFeed({
             dirty = true;
           }
           break;
+        case "managed-checkpoint-settled":
+          log.recordManagedCheckpoint(turnId, {
+            toolUseId: event.tool_use_id,
+            tool: event.tool,
+            transactionId: event.transaction_id,
+            checkpointId: event.id,
+            evidenceDigest: event.evidence_digest,
+            phase: event.phase,
+            coverage: event.coverage,
+            fileCoverage: event.file_coverage,
+          });
+          dirty = true;
+          break;
+        case "managed-checkpoint-error":
+          if (event.phase !== "prepare" && event.recovery_required === true) {
+            log.recordManagedCheckpoint(turnId, {
+              toolUseId: event.tool_use_id,
+              tool: event.tool,
+              transactionId: event.transaction_id,
+              checkpointId: event.checkpoint_id,
+              phase: event.phase || "settle",
+              coverage: TURN_COVERAGE.NONE,
+              fileCoverage: TURN_COVERAGE.NONE,
+            });
+            dirty = true;
+          }
+          break;
         case "tool-executing": {
           const callId =
             event.tool_use_id == null