chainlesschain 0.165.5 → 0.165.8

package/src/harness/jsonl-session-store.js

@@ -24,7 +24,8 @@ import fs, {
 import { join, basename, dirname, resolve } from "node:path";
 import { createHash, randomUUID } from "node:crypto";
 import { TextDecoder } from "node:util";
-import { getHomeDir } from "../lib/paths.js";
+import { ensureClaudeProjectStorageTree, getHomeDir } from "../lib/paths.js";
+import { resolveClaudeProjectStorageDir } from "../lib/claude-project-storage-layout.js";
 import { ensurePrivateDirectory, ensurePrivateFile } from "../lib/secure-fs.js";
 import {
   isAffectedWindowsZeroDeviceStatRuntime,
@@ -78,9 +79,9 @@ import {
 } from "../lib/execution-location-contract.js";
 import { canonicalJson } from "../lib/scheduler-kernel/contract.js";
 import {
-  listSessionAntiRollbackIds,
-  publishSessionAntiRollbackAnchor,
-  readSessionAntiRollbackAnchor,
+  listSessionAntiRollbackIds as listSessionAntiRollbackIdsForStore,
+  publishSessionAntiRollbackAnchor as publishSessionAntiRollbackAnchorForStore,
+  readSessionAntiRollbackAnchor as readSessionAntiRollbackAnchorForStore,
   sessionAntiRollbackPredecessorWitness,
 } from "../lib/session-anti-rollback-anchor.js";
 import { normalizeSessionBudgetRootConfig } from "../lib/session-budget-production-root.js";
@@ -92,6 +93,8 @@ import { normalizeExecutionLocationResultStoreReceipt } from "../lib/execution-l
 
 let securedSessionsDir = null;
 let securedSessionsDirIdentity = null;
+let securedSessionHostLeaseRoot = null;
+let securedSessionHostLeaseRootIdentity = null;
 
 // Deterministic process-crash injection for the independent session-scale
 // gate. The hooks are inert unless the dedicated child process opts in; this
@@ -169,6 +172,21 @@ const WS_TURN_REQUEST_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:@-]*$/;
 const WS_TURN_INPUT_DIGEST_PATTERN = /^sha256:[0-9a-f]{64}$/;
 const WS_TURN_CLAIM_ID_PATTERN = /^claim-[0-9a-f-]{36}$/;
 const WS_TURN_FAILURE_CODE_PATTERN = /^[A-Z][A-Z0-9_]{0,63}$/;
+// Windows antivirus and directory-replacement latency make a legitimate
+// cross-process append queue materially longer than on POSIX. Keep the same
+// strict owner/token protocol, but give a live owner enough time to drain a
+// high-contention queue instead of reporting a false lock-unavailable error.
+const SESSION_APPEND_LOCK_TIMEOUT_MS =
+  process.platform === "win32" ? 120_000 : 30_000;
+const SESSION_APPEND_LOCK_YIELD_AFTER_RELEASE_MS =
+  // Every append releases the directory lock before this bounded handoff.
+  // On a two-core hosted Windows runner, an 8 ms pause lets the just-released
+  // writer reacquire before waiters that are still in their 1–12 ms backoff.
+  // The resulting writer starvation makes the formal 20×1000 matrix time out
+  // despite every individual operation being healthy.  Leave enough room for
+  // an existing contender to wake, while retaining the same strict lock and
+  // the full append workload.
+  process.platform === "win32" ? 32 : 2;
 
 export {
   SESSION_GENERATION_AUTHORITY_FIELD,
@@ -678,7 +696,9 @@ function fsyncParentDirectory(filePath, payload, beforeHook, afterHook) {
 }
 
 function getSessionsDir() {
-  const dir = join(getHomeDir(), "sessions");
+  const homeDir = getHomeDir();
+  const claudeProjectDir = resolveClaudeProjectStorageDir(homeDir);
+  const dir = claudeProjectDir || join(homeDir, "sessions");
   let current = null;
   try {
     current = lstatSync(dir);
@@ -697,7 +717,11 @@ function getSessionsDir() {
     currentIdentity !== securedSessionsDirIdentity ||
     unsafePosixMode
   ) {
-    ensurePrivateDirectory(dir);
+    if (claudeProjectDir) {
+      ensureClaudeProjectStorageTree(homeDir, claudeProjectDir);
+    } else {
+      ensurePrivateDirectory(dir);
+    }
     securedSessionsDir = dir;
     const secured = lstatSync(dir);
     securedSessionsDirIdentity = `${secured.dev}:${secured.ino}`;
@@ -705,6 +729,71 @@ function getSessionsDir() {
   return dir;
 }
 
+/**
+ * Keep the legacy anchor namespace keyed by CHAINLESSCHAIN_HOME, while a
+ * Claude project gets an independent namespace keyed by its project bucket.
+ * Otherwise two project buckets using the same session id would conflict in
+ * the machine-local anti-rollback witness.
+ */
+function sessionAntiRollbackPathOptions() {
+  const homeDir = getHomeDir();
+  return {
+    homeDir: resolveClaudeProjectStorageDir(homeDir) || homeDir,
+  };
+}
+
+function readSessionAntiRollbackAnchor(sessionId) {
+  return readSessionAntiRollbackAnchorForStore(
+    sessionId,
+    sessionAntiRollbackPathOptions(),
+  );
+}
+
+function listSessionAntiRollbackIds() {
+  return listSessionAntiRollbackIdsForStore(sessionAntiRollbackPathOptions());
+}
+
+/**
+ * The legacy lease authority intentionally stays at the historical global
+ * state root. Claude project transcripts instead receive a lease directory
+ * beside their JSONL so identical ids in separate project buckets cannot
+ * fence one another. Cache the verified directory identity to avoid repeated
+ * ACL batches on every append.
+ */
+function sessionHostLeaseOptions() {
+  const homeDir = getHomeDir();
+  const projectDir = resolveClaudeProjectStorageDir(homeDir);
+  if (!projectDir) return null;
+  const stateRoot = join(projectDir, "session-host-leases");
+  let current = null;
+  try {
+    current = lstatSync(stateRoot);
+  } catch {
+    // The secure tree helper creates a missing root below.
+  }
+  const identity = current ? `${current.dev}:${current.ino}` : null;
+  const unsafePosixMode =
+    process.platform !== "win32" &&
+    current !== null &&
+    (current.mode & 0o777) !== 0o700;
+  if (
+    !current ||
+    !current.isDirectory() ||
+    current.isSymbolicLink() ||
+    unsafePosixMode ||
+    stateRoot !== securedSessionHostLeaseRoot ||
+    identity !== securedSessionHostLeaseRootIdentity
+  ) {
+    ensureClaudeProjectStorageTree(homeDir, projectDir, {
+      extraDirectories: [stateRoot],
+    });
+    const secured = lstatSync(stateRoot);
+    securedSessionHostLeaseRoot = stateRoot;
+    securedSessionHostLeaseRootIdentity = `${secured.dev}:${secured.ino}`;
+  }
+  return { stateRoot };
+}
+
 /**
  * A session id must be a single safe path segment. Ids are generated as
  * `session-<ts>-<hex>`, but also arrive from CLI args (`cc agent --resume <id>`,
@@ -799,7 +888,11 @@ function samePhysicalTranscriptState(left, right, { content = true } = {}) {
   );
 }
 
-function samePhysicalTranscriptContentState(left, right) {
+function samePhysicalTranscriptContentState(
+  left,
+  right,
+  { includeCtime = true } = {},
+) {
   if (!left || !right) return left === right;
   const sameField = (exactField, legacyField) => {
     if (left[exactField] != null && right[exactField] != null) {
@@ -810,7 +903,7 @@ function samePhysicalTranscriptContentState(left, right) {
   return (
     sameField("sizeExact", "size") &&
     sameField("mtimeNs", "mtimeMs") &&
-    sameField("ctimeNs", "ctimeMs")
+    (!includeCtime || sameField("ctimeNs", "ctimeMs"))
   );
 }
 
@@ -1072,7 +1165,12 @@ function appendVerifiedWsAuthorityEventLocked(
 function withSessionHostWriterLock(sessionId, filePath, task, options) {
   return withFileLock(
     filePath,
-    () => withSessionHostWriteAuthority(sessionId, task),
+    () =>
+      withSessionHostWriteAuthority(
+        sessionId,
+        task,
+        sessionHostLeaseOptions() || undefined,
+      ),
     options,
   );
 }
@@ -1459,7 +1557,8 @@ function publishSessionAntiRollbackWitness(
     error.code = "CC_SESSION_ANTI_ROLLBACK_UNAVAILABLE";
     throw error;
   }
-  return publishSessionAntiRollbackAnchor(sessionId, candidate, {
+  return publishSessionAntiRollbackAnchorForStore(sessionId, candidate, {
+    ...sessionAntiRollbackPathOptions(),
     provePrefix: (current) =>
       current.status === "live" &&
       existsSync(filePath) &&
@@ -1710,11 +1809,11 @@ function appendEventLocked(
     },
     {
       failIfUnavailable: true,
-      timeoutMs: 30_000,
+      timeoutMs: SESSION_APPEND_LOCK_TIMEOUT_MS,
       retryMs: 1,
       maxRetryMs: 8,
       retryJitterMs: 4,
-      yieldAfterReleaseMs: 2,
+      yieldAfterReleaseMs: SESSION_APPEND_LOCK_YIELD_AFTER_RELEASE_MS,
     },
   );
 }
@@ -3655,6 +3754,101 @@ function sessionReplicaReceipt(sessionId, expected, installed) {
   });
 }
 
+/**
+ * Windows ACL enforcement can advance ctime without changing a transcript's
+ * bytes, mtime, or file identity. A target process normally observes that only
+ * after a prior replica install has already sealed the sidecar witness. Before
+ * accepting that narrow drift, re-verify the full hash chain and retain the
+ * independent anti-rollback witness check performed by
+ * assertVerifiedTranscriptAnchor(). Any content, identity, head, or count
+ * mismatch remains fail-closed.
+ *
+ * Callers must already hold the session host writer lock.
+ */
+function resealWindowsAclMetadataWitnessUnlocked(
+  sessionId,
+  sessionsDir,
+  filePath,
+  meta,
+) {
+  if (
+    process.platform !== "win32" ||
+    meta?.deleted === true ||
+    !meta?.transcript
+  ) {
+    return null;
+  }
+
+  let before;
+  try {
+    before = readPhysicalTranscriptState(filePath);
+  } catch {
+    return null;
+  }
+  if (samePhysicalTranscriptState(meta.transcript, before)) {
+    return null;
+  }
+  if (
+    !samePhysicalTranscriptState(meta.transcript, before, {
+      content: false,
+    }) ||
+    !samePhysicalTranscriptContentState(meta.transcript, before, {
+      includeCtime: false,
+    })
+  ) {
+    return null;
+  }
+
+  const verification = verifyTranscriptFile(filePath);
+  const after = readPhysicalTranscriptState(filePath);
+  if (!samePhysicalTranscriptState(before, after)) {
+    throw transcriptIdentityError(
+      "not-committed",
+      "the transcript changed while its ACL metadata drift was verified",
+    );
+  }
+  if (
+    verification.status !== TRANSCRIPT_CHAIN_STATUS.VERIFIED ||
+    verification.malformedLines > 0 ||
+    verification.truncatedTail ||
+    verification.lastHash !== meta.last_hash ||
+    verification.chainedEvents !== Number(meta.event_count)
+  ) {
+    return null;
+  }
+
+  const resealed = rebuildSessionMetaUnlocked(sessionsDir, sessionId, filePath);
+  assertVerifiedTranscriptAnchor(sessionId, verification, resealed.transcript);
+  return resealed;
+}
+
+function resealWindowsAclMetadataWitness(sessionId) {
+  if (process.platform !== "win32") return null;
+  const filePath = sessionPath(sessionId);
+  const sessionsDir = getSessionsDir();
+  return withSessionHostWriterLock(
+    sessionId,
+    filePath,
+    () => {
+      const meta = readSessionMeta(sessionsDir, sessionId);
+      return resealWindowsAclMetadataWitnessUnlocked(
+        sessionId,
+        sessionsDir,
+        filePath,
+        meta,
+      );
+    },
+    {
+      failIfUnavailable: true,
+      timeoutMs: 30_000,
+      retryMs: 1,
+      maxRetryMs: 8,
+      retryJitterMs: 4,
+      yieldAfterReleaseMs: 2,
+    },
+  );
+}
+
 function sessionLocationDigest(domain, value) {
   return `sha256:${createHash("sha256")
     .update(domain, "utf8")
@@ -4005,7 +4199,7 @@ function createSessionResultCollectionSettlementData(
     gaps: collection.gaps,
   };
   if (
-    !["wsl", "ssh", "container"].includes(collection.target) ||
+    !["local", "wsl", "ssh", "container"].includes(collection.target) ||
     collection.continuity !== "single-fixed-command-response" ||
     JSON.stringify(collection.gaps) !==
       JSON.stringify([
@@ -4085,7 +4279,9 @@ function normalizeSessionResultCollectionSettlementData(sessionId, data) {
     !isLegacy &&
     data.schema !== SESSION_EXECUTION_LOCATION_RESULT_COLLECTION_SCHEMA
   ) {
-    throw new TypeError("session result collection settlement schema is invalid");
+    throw new TypeError(
+      "session result collection settlement schema is invalid",
+    );
   }
   const source = normalizeSessionResultCollectionSource(data.source, sessionId);
   const target = exactRecord(
@@ -4216,7 +4412,9 @@ function projectSessionResultCollectionSettlement(
     !legacy &&
     data.schema !== SESSION_EXECUTION_LOCATION_RESULT_COLLECTION_SCHEMA
   ) {
-    throw new TypeError("session result collection settlement schema is invalid");
+    throw new TypeError(
+      "session result collection settlement schema is invalid",
+    );
   }
   const normalized = normalizeSessionResultCollectionSettlementData(
     sessionId,
@@ -4295,7 +4493,9 @@ export function readVerifiedSessionExecutionLocationResultSettlement(
     return {
       accept(event) {
         eventCount += 1;
-        if (event?.type !== SESSION_EXECUTION_LOCATION_RESULT_COLLECTION_EVENT) {
+        if (
+          event?.type !== SESSION_EXECUTION_LOCATION_RESULT_COLLECTION_EVENT
+        ) {
           return;
         }
         const settlement = projectSessionResultCollectionSettlement(
@@ -4403,11 +4603,7 @@ export function settleSessionExecutionLocationResultCollection(
 }
 
 function normalizeSessionResultApplyId(value) {
-  const applyId = boundedAuthorityString(
-    value,
-    "result apply id",
-    128,
-  );
+  const applyId = boundedAuthorityString(value, "result apply id", 128);
   if (!/^[A-Za-z0-9][A-Za-z0-9._:@-]{0,127}$/u.test(applyId)) {
     throw new TypeError("result apply id is invalid");
   }
@@ -4445,7 +4641,11 @@ function normalizeSessionResultApplyPreparedTransaction(input) {
     ],
     "result apply prepared transaction",
   );
-  const id = boundedAuthorityString(value.id, "result apply transaction id", 192);
+  const id = boundedAuthorityString(
+    value.id,
+    "result apply transaction id",
+    192,
+  );
   const checkpointId = boundedAuthorityString(
     value.checkpointId,
     "result apply checkpoint id",
@@ -4628,7 +4828,9 @@ function projectSessionResultApplyReservation(
     eventCount !== settlement.eventCount + 1 ||
     data.applied !== false
   ) {
-    throw new TypeError("session result apply reservation predecessor is invalid");
+    throw new TypeError(
+      "session result apply reservation predecessor is invalid",
+    );
   }
   const material = {
     schema: SESSION_EXECUTION_LOCATION_RESULT_APPLY_RESERVATION_SCHEMA,
@@ -4838,7 +5040,9 @@ export function readVerifiedSessionExecutionLocationResultApply(
     return {
       accept(event) {
         eventCount += 1;
-        if (event?.type === SESSION_EXECUTION_LOCATION_RESULT_COLLECTION_EVENT) {
+        if (
+          event?.type === SESSION_EXECUTION_LOCATION_RESULT_COLLECTION_EVENT
+        ) {
           const settlement = projectSessionResultCollectionSettlement(
             sessionId,
             event,
@@ -4847,7 +5051,10 @@ export function readVerifiedSessionExecutionLocationResultApply(
           settlements.set(settlement.settlementId, settlement);
           return;
         }
-        if (event?.type === SESSION_EXECUTION_LOCATION_RESULT_APPLY_RESERVATION_EVENT) {
+        if (
+          event?.type ===
+          SESSION_EXECUTION_LOCATION_RESULT_APPLY_RESERVATION_EVENT
+        ) {
           const settlement = settlements.get(event?.data?.settlementId) || null;
           const reservation = projectSessionResultApplyReservation(
             sessionId,
@@ -4866,7 +5073,9 @@ export function readVerifiedSessionExecutionLocationResultApply(
           reservations.set(reservation.applyId, reservation);
           return;
         }
-        if (event?.type === SESSION_EXECUTION_LOCATION_RESULT_APPLY_TERMINAL_EVENT) {
+        if (
+          event?.type === SESSION_EXECUTION_LOCATION_RESULT_APPLY_TERMINAL_EVENT
+        ) {
           const reservation = reservations.get(event?.data?.applyId) || null;
           const terminal = projectSessionResultApplyTerminal(
             sessionId,
@@ -4924,7 +5133,11 @@ export function reserveSessionExecutionLocationResultApply(
     if (prior.reservation.reservationId !== data.reservationId) {
       throw new Error("result apply id is already bound to different inputs");
     }
-    return Object.freeze({ ...prior, reservationAppended: false, recovered: true });
+    return Object.freeze({
+      ...prior,
+      reservationAppended: false,
+      recovered: true,
+    });
   }
   appendAuthorityEventIfHead(
     sessionId,
@@ -4934,7 +5147,11 @@ export function reserveSessionExecutionLocationResultApply(
   );
   runSessionScaleFaultHook(
     "afterResultApplyReservationAppend",
-    Object.freeze({ sessionId, applyId: data.applyId, reservationId: data.reservationId }),
+    Object.freeze({
+      sessionId,
+      applyId: data.applyId,
+      reservationId: data.reservationId,
+    }),
   );
   const receipt = readVerifiedSessionExecutionLocationResultApply(
     sessionId,
@@ -4946,7 +5163,11 @@ export function reserveSessionExecutionLocationResultApply(
   ) {
     throw new Error("result apply reservation is not canonical");
   }
-  return Object.freeze({ ...receipt, reservationAppended: true, recovered: false });
+  return Object.freeze({
+    ...receipt,
+    reservationAppended: true,
+    recovered: false,
+  });
 }
 
 export function settleSessionExecutionLocationResultApply(
@@ -4956,13 +5177,15 @@ export function settleSessionExecutionLocationResultApply(
   transaction,
 ) {
   const applyId = normalizeSessionResultApplyId(applyIdInput);
-  const prior = readVerifiedSessionExecutionLocationResultApply(sessionId, applyId);
+  const prior = readVerifiedSessionExecutionLocationResultApply(
+    sessionId,
+    applyId,
+  );
   if (prior === null) {
     throw new Error("result apply reservation was not found");
   }
-  const normalizedTransaction = normalizeSessionResultApplyTerminalTransaction(
-    transaction,
-  );
+  const normalizedTransaction =
+    normalizeSessionResultApplyTerminalTransaction(transaction);
   if (prior.terminal !== null) {
     if (
       prior.status !== outcome ||
@@ -4971,7 +5194,11 @@ export function settleSessionExecutionLocationResultApply(
     ) {
       throw new Error("result apply is already settled differently");
     }
-    return Object.freeze({ ...prior, terminalAppended: false, recovered: true });
+    return Object.freeze({
+      ...prior,
+      terminalAppended: false,
+      recovered: true,
+    });
   }
   const current = getVerifiedSessionExecutionLocationAuthority(sessionId);
   const reservation = Object.freeze({
@@ -5010,17 +5237,28 @@ export function settleSessionExecutionLocationResultApply(
     ) {
       throw error;
     }
-    return Object.freeze({ ...raced, terminalAppended: false, recovered: true });
+    return Object.freeze({
+      ...raced,
+      terminalAppended: false,
+      recovered: true,
+    });
   }
   runSessionScaleFaultHook(
     "afterResultApplyTerminalAppend",
     Object.freeze({ sessionId, applyId, terminalId: data.terminalId }),
   );
-  const receipt = readVerifiedSessionExecutionLocationResultApply(sessionId, applyId);
+  const receipt = readVerifiedSessionExecutionLocationResultApply(
+    sessionId,
+    applyId,
+  );
   if (receipt?.terminal?.terminalId !== data.terminalId) {
     throw new Error("result apply terminal is not canonical");
   }
-  return Object.freeze({ ...receipt, terminalAppended: true, recovered: false });
+  return Object.freeze({
+    ...receipt,
+    terminalAppended: true,
+    recovered: false,
+  });
 }
 
 /**
@@ -5059,6 +5297,9 @@ export function installSessionReplica(sessionId, input, expectedInput) {
     sessionsDir,
     `.${basename(filePath)}.replica.pending`,
   );
+  if (getSessionPresence(sessionId) === SESSION_PRESENCE.PRESENT) {
+    resealWindowsAclMetadataWitness(sessionId);
+  }
   return withSessionHostWriterLock(
     sessionId,
     filePath,
@@ -5212,6 +5453,7 @@ export function installSessionReplicaWithLocationHandoff(
   );
 
   if (getSessionPresence(sessionId) === SESSION_PRESENCE.PRESENT) {
+    resealWindowsAclMetadataWitness(sessionId);
     const current = getVerifiedSessionExecutionLocationAuthority(sessionId);
     if (current.locationHandoff !== null) {
       if (current.locationHandoff.handoffId !== handoff.handoffId) {