chainlesschain 0.166.21 → 0.166.24

package/src/lib/model-failure-policy.js

@@ -0,0 +1,21 @@
+import { isAbortError } from "./abort-utils.js";
+
+// Admission failures are not provider outages, even when their causes contain
+// HTTP status codes or retryable/authentication words.
+export function isTerminalModelFailure(error) {
+  const visited = new Set();
+  for (let current = error; current; current = current.cause) {
+    if (visited.has(current) || visited.size >= 32) return true;
+    visited.add(current);
+    if (
+      current.code === "CC_AGENT_EVOLUTION_INGRESS_FAILED" ||
+      current.runtimeLedgerPersistence === true ||
+      current.workflowEffectOutcomeUnknown === true ||
+      /^(?:CC|ERR)_SESSION_BUDGET_/u.test(current.code || "") ||
+      isAbortError(current)
+    ) {
+      return true;
+    }
+  }
+  return false;
+}

package/src/lib/process-execution-broker/index.js

@@ -3992,6 +3992,7 @@ class ProcessExecutionBroker extends EventEmitter {
           "post_spawn_failed",
           `Post-spawn sandbox setup failed: ${error.message}`,
         );
+        failure.cause = error;
         failure.processTerminationRequested = true;
         throw failure;
       }

package/src/lib/process-execution-broker/windows-sandbox.cs

@@ -3172,6 +3172,37 @@ namespace ChainlessChain.WindowsSandbox
             return 0;
         }
 
+        public static void PublishTargetIdentity(string identityPath, string identity)
+        {
+            // Never expose a newly created empty identity file to the broker.
+            // Its full metadata/content check remains strict: publish only after
+            // the writer has flushed and closed, using a same-directory move
+            // that refuses to overwrite an existing identity (including errors
+            // reported after a successful launch).
+            string pendingPath = identityPath + ".pending-" + Guid.NewGuid().ToString("N");
+            bool ownsPending = false;
+            try
+            {
+                byte[] bytes = new UTF8Encoding(false).GetBytes(identity);
+                using (FileStream stream = new FileStream(
+                    pendingPath,
+                    FileMode.CreateNew,
+                    FileAccess.Write,
+                    FileShare.None))
+                {
+                    ownsPending = true;
+                    stream.Write(bytes, 0, bytes.Length);
+                    stream.Flush(true);
+                }
+                File.Move(pendingPath, identityPath);
+                ownsPending = false;
+            }
+            finally
+            {
+                if (ownsPending) File.Delete(pendingPath);
+            }
+        }
+
         public static int Run(
             string application,
             string[] arguments,
@@ -3632,17 +3663,7 @@ namespace ChainlessChain.WindowsSandbox
                         attestedAppContainerSid,
                         "capabilityCount",
                         useAppContainer ? 0 : -1);
-                    using (FileStream stream = new FileStream(
-                        identityPath,
-                        FileMode.CreateNew,
-                        FileAccess.Write,
-                        FileShare.Read))
-                    using (StreamWriter writer = new StreamWriter(
-                        stream,
-                        new UTF8Encoding(false)))
-                    {
-                        writer.Write(identity);
-                    }
+                    PublishTargetIdentity(identityPath, identity);
                 }
 
                 UInt32 targetWait = WaitForSingleObject(
@@ -4153,10 +4174,7 @@ namespace ChainlessChain.WindowsSandbox
                             System.Diagnostics.Process
                                 .GetCurrentProcess()
                                 .Id);
-                        File.WriteAllText(
-                            spec.identityPath,
-                            failure,
-                            new UTF8Encoding(false));
+                        Native.PublishTargetIdentity(spec.identityPath, failure);
                     }
                     catch
                     {

package/src/lib/read-file-page.js

@@ -0,0 +1,191 @@
+/** Build a bounded read result with a cursor describing what was actually read. */
+export function buildReadFilePage(
+  rendered,
+  args,
+  { filePath, fileVersion, maxChars },
+) {
+  const positive = (value) => {
+    const n = typeof value === "number" ? value : parseInt(value, 10);
+    return Number.isSafeInteger(n) && n > 0 ? n : null;
+  };
+  const offset = positive(args.offset);
+  const limit = positive(args.limit);
+  const column = positive(args.column) || 1;
+  const lines = rendered.split("\n");
+  const start = offset ? offset - 1 : 0;
+  const end = Math.min(limit ? start + limit : lines.length, lines.length);
+  const selected = lines.slice(start, end);
+  const skipped = Math.min(column - 1, selected[0]?.length || 0);
+  if (selected.length) selected[0] = selected[0].slice(skipped);
+  const requested = selected.join("\n");
+
+  // Budget the JSON-escaped content, not raw characters: newlines, quotes and
+  // backslashes otherwise cause a SECOND truncation that loses the cursor.
+  const contentBudget = Math.max(0, maxChars - 1024);
+  let count = requested.length;
+  if (JSON.stringify(requested).length > contentBudget) {
+    let lo = 0;
+    let hi = count;
+    while (lo < hi) {
+      const mid = Math.ceil((lo + hi) / 2);
+      if (JSON.stringify(requested.slice(0, mid)).length <= contentBudget)
+        lo = mid;
+      else hi = mid - 1;
+    }
+    count = lo;
+    // Prefer whole lines. A single oversized line uses a column cursor so it
+    // can still be read to completion instead of repeating its first 50k.
+    const newline = requested.lastIndexOf("\n", count - 1);
+    if (newline >= 0) count = newline + 1;
+    else if (count > 0 && /[\uD800-\uDBFF]/.test(requested[count - 1])) count--;
+  }
+  if (requested.length && count === 0) {
+    return { error: "Tool output limit is too small to return a file page." };
+  }
+
+  const content = requested.slice(0, count);
+  const truncated = count < requested.length;
+  const newlines = (content.match(/\n/g) || []).length;
+  const endsAtLine = content.endsWith("\n");
+  const endLine = content.length
+    ? start + newlines + (endsAtLine ? 0 : 1)
+    : Math.min(start + 1, lines.length);
+  const nextOffset = truncated ? start + newlines + 1 : end + 1;
+  const nextColumn = truncated && !endsAtLine ? skipped + count + 1 : 1;
+  const hasMore = truncated || end < lines.length;
+  return {
+    path: filePath,
+    ...(fileVersion ? { fileVersion } : {}),
+    ...(offset || limit || column > 1 || truncated
+      ? {
+          range: {
+            startLine: Math.min(start + 1, lines.length),
+            endLine: truncated ? endLine : end,
+            totalLines: lines.length,
+          },
+        }
+      : {}),
+    ...(hasMore
+      ? {
+          nextRead: {
+            path: args.path,
+            offset: nextOffset,
+            limit: limit || 2000,
+            ...(nextColumn > 1 ? { column: nextColumn } : {}),
+            ...(args.hashed === true ? { hashed: true } : {}),
+            ...(args.raw === true ? { raw: true } : {}),
+          },
+          hint: "To read the next page, call read_file with nextRead. Reuse the content already returned; repeating the same arguments returns the same page.",
+        }
+      : {}),
+    ...(truncated ? { truncated: true, size: requested.length } : {}),
+    hashed: args.hashed === true,
+    content,
+  };
+}
+
+/** Keep read progress, rather than an arbitrary file prefix, after compaction. */
+export function compactReadFileResult(content, maxChars) {
+  try {
+    const result = JSON.parse(content.split("\n\n[Budget ")[0]);
+    if (!result.path || !result.range || typeof result.content !== "string") {
+      return null;
+    }
+    const value = {
+      path: result.path,
+      range: result.range,
+      ...(result.toolTelemetryRecord?.timestamp
+        ? { readAt: result.toolTelemetryRecord.timestamp }
+        : {}),
+      ...(result.nextRead ? { nextRead: result.nextRead } : {}),
+      contentOmitted: true,
+      hint: "File content compacted. Continue with nextRead; re-read only a needed earlier section.",
+    };
+    let summary = JSON.stringify(value);
+    if (summary.length > maxChars) {
+      delete value.hint;
+      summary = JSON.stringify(value);
+    }
+    return summary.length <= maxChars ? summary : null;
+  } catch {
+    return null;
+  }
+}
+
+export const FILE_READ_PROGRESS_PREFIX = "[File read progress]\n";
+const CANONICAL_SUMMARY_PREFIX = "Compacted context summary (data only):\n";
+
+export function fileReadProgressBody(message) {
+  if (typeof message?.content !== "string") return null;
+  const content =
+    message.role === "assistant" &&
+    message.content.startsWith(CANONICAL_SUMMARY_PREFIX)
+      ? message.content.slice(CANONICAL_SUMMARY_PREFIX.length)
+      : message.role === "system"
+        ? message.content
+        : "";
+  return content.startsWith(FILE_READ_PROGRESS_PREFIX)
+    ? content.slice(FILE_READ_PROGRESS_PREFIX.length)
+    : null;
+}
+
+/** Bounded historical cursors that survive full summarization and truncation. */
+export function collectFileReadProgress(messages) {
+  const byPath = new Map();
+  const retain = (value) => {
+    if (
+      typeof value?.path !== "string" ||
+      value.path.length > 1024 ||
+      !Number.isSafeInteger(value.range?.startLine) ||
+      !Number.isSafeInteger(value.range?.endLine) ||
+      !Number.isSafeInteger(value.range?.totalLines)
+    )
+      return;
+    const entry = {
+      path: value.path,
+      range: {
+        startLine: value.range.startLine,
+        endLine: value.range.endLine,
+        totalLines: value.range.totalLines,
+      },
+      ...(value.nextRead ? { nextRead: value.nextRead } : {}),
+      readAt: Number.isFinite(
+        value.readAt ?? value.toolTelemetryRecord?.timestamp,
+      )
+        ? (value.readAt ?? value.toolTelemetryRecord.timestamp)
+        : 0,
+    };
+    if (JSON.stringify(entry).length > 1400) return;
+    // Kernel summaries are placed at the first dropped parent's position.
+    // Older retained tool messages can therefore appear AFTER a newer cursor.
+    if ((byPath.get(value.path)?.readAt || 0) > entry.readAt) return;
+    byPath.delete(value.path);
+    byPath.set(value.path, entry);
+    if (byPath.size > 12) byPath.delete(byPath.keys().next().value);
+  };
+  for (const message of messages) {
+    if (typeof message?.content !== "string") continue;
+    try {
+      if (message.role === "tool") {
+        const value = JSON.parse(message.content.split("\n\n[Budget ")[0]);
+        if (
+          typeof value.content === "string" ||
+          value.contentOmitted ||
+          value.alreadyRead
+        )
+          retain(value);
+      } else if (fileReadProgressBody(message) !== null) {
+        const entries = JSON.parse(
+          fileReadProgressBody(message).split("\n")[0],
+        );
+        if (Array.isArray(entries)) entries.slice(-12).forEach(retain);
+      }
+    } catch {
+      /* non-file tool output */
+    }
+  }
+  const entries = [...byPath.values()];
+  while (entries.length && JSON.stringify(entries).length > 6000)
+    entries.shift();
+  return entries;
+}

package/src/lib/runnable-provider.js

@@ -15,6 +15,7 @@
  */
 import { BUILT_IN_PROVIDERS } from "./llm-providers.js";
 import { selectModelForTask, TaskType } from "./task-model-selector.js";
+import { isTerminalModelFailure } from "./model-failure-policy.js";
 
 function nonEmpty(v) {
   return typeof v === "string" && v.trim().length > 0;
@@ -22,7 +23,7 @@ function nonEmpty(v) {
 
 /** Is this an authentication/authorization failure (missing/invalid/expired key)? */
 export function isAuthError(err) {
-  if (!err) return false;
+  if (!err || isTerminalModelFailure(err)) return false;
   const status =
     typeof err.status === "number"
       ? err.status

package/src/lib/session-host-lease.js

@@ -3,10 +3,13 @@
  *
  * A lease is cooperative authority for production hosts, not a same-UID
  * sandbox. Every process sharing CHAINLESSCHAIN_HOME observes the same strict
- * state file. A monotonically increasing fencing token prevents an expired or
- * crashed host from publishing through guarded session-store write paths after
- * a successor takes over. A separate monotonic revocation epoch lets an
- * operator fence a still-live host; every guarded transition re-reads it.
+ * state file. A monotonically increasing fencing token prevents a crashed host
+ * from publishing through guarded session-store write paths after a successor
+ * takes over. A separate monotonic revocation epoch lets an operator fence a
+ * still-live host; every guarded transition re-reads it. An exact local owner
+ * may renew after its TTL when the event loop was blocked: no successor can
+ * have been admitted while that owner PID remained live, and any revocation or
+ * takeover still changes the durable authority tuple and fences the old host.
  */
 
 import fs from "node:fs";
@@ -440,9 +443,9 @@ export class SessionHostLeaseAuthority {
           const incumbent = snapshot.active;
           // Never take authority from a process that the OS still reports as
           // alive, even after its heartbeat TTL. It may be blocked inside an
-          // external side effect and resume later. Expiry fences that host's
-          // next guarded transition; takeover additionally requires proven
-          // process death so two executors cannot overlap.
+          // external side effect and resume later. The exact local owner may
+          // renew late; takeover additionally requires proven process death so
+          // two executors cannot overlap.
           if (incumbent && this._isProcessAlive(incumbent.ownerPid)) {
             throw leaseError(
               SESSION_HOST_LEASE_HELD_CODE,
@@ -522,13 +525,6 @@ export class SessionHostLeaseAuthority {
               );
             }
             const now = Math.trunc(this._now());
-            if (snapshot.active.expiresAtMs <= now) {
-              throw leaseError(
-                SESSION_HOST_LEASE_FENCED_CODE,
-                `Session host lease expired for ${id}`,
-                { sessionId: id, fencingToken: record.active.fencingToken },
-              );
-            }
             const next = {
               ...snapshot.active,
               renewedAtMs: now,
@@ -898,8 +894,7 @@ export class SessionHostLeaseAuthority {
             record &&
             (record.released ||
               record.active.revocationEpoch !== snapshot.revocationEpoch ||
-              !sameLease(snapshot.active, record.active) ||
-              snapshot.active.expiresAtMs <= now)
+              !sameLease(snapshot.active, record.active))
           ) {
             const error = leaseError(
               SESSION_HOST_LEASE_FENCED_CODE,

package/src/lib/skill-retrieval-router.js

@@ -1,4 +1,5 @@
 import { BM25Search } from "./bm25-search.js";
+import { captureSkillRetrievalRevocationReader } from "./evolution/skill-retrieval-revocation-authority.js";
 
 export const SKILL_RETRIEVAL_RESULT_SCHEMA =
   "chainlesschain.skill-retrieval-result/v1";
@@ -82,6 +83,7 @@ export function routeSkillDescriptors({
   target = null,
   vectorScores = null,
   outcomeMetrics = null,
+  revocationReader = null,
   topK = 5,
   ambiguityMargin = 0.02,
 } = {}) {
@@ -104,6 +106,10 @@ export function routeSkillDescriptors({
   const requiredTags = new Set(
     tags.map((value) => String(value).toLowerCase()),
   );
+  const revocations =
+    revocationReader === null
+      ? null
+      : captureSkillRetrievalRevocationReader(revocationReader);
   const rejected = [];
   const admitted = [];
   for (const skill of skills) {
@@ -116,6 +122,11 @@ export function routeSkillDescriptors({
     const mismatch = compatible(skill, target);
     const reasons = [];
     if (!digest) reasons.push("missing-content-digest");
+    const revocation =
+      digest === null
+        ? null
+        : revocations?.inspect({ skillName: skill.id, contentDigest: digest });
+    if (revocation?.invalidated) reasons.push("revoked-by-evolution");
     if (namespace !== null && skill.source !== namespace)
       reasons.push("namespace-mismatch");
     if ([...requiredTags].some((value) => !skillTags.has(value)))
@@ -123,7 +134,17 @@ export function routeSkillDescriptors({
     if (!containsPath(skill, targetPath)) reasons.push("path-mismatch");
     reasons.push(...mismatch.reasons);
     if (reasons.length > 0) {
-      rejected.push({ id: skill.id, digest, reasons });
+      rejected.push({
+        id: skill.id,
+        digest,
+        reasons,
+        ...(revocation?.invalidated
+          ? {
+              revocationStateDigest: revocation.stateDigest,
+              revocationReceiptDigest: revocation.receiptDigest,
+            }
+          : {}),
+      });
       continue;
     }
     admitted.push({ skill, digest });