chainlesschain 0.166.22 → 0.166.24

package/src/lib/evolution/wikiskill-benchmark.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 
 export const WIKISKILL_BENCHMARK_PLAN_SCHEMA =
-  "chainlesschain.wikiskill-benchmark-plan/v1";
+  "chainlesschain.wikiskill-benchmark-plan/v2";
 export const WIKISKILL_BENCHMARK_REPORT_SCHEMA =
   "chainlesschain.wikiskill-benchmark-report/v1";
 export const WIKISKILL_BENCHMARK_ENVELOPE_SCHEMA =
@@ -102,6 +102,7 @@ export function createWikiSkillBenchmarkPlan(input = {}) {
     [
       "gitCommit",
       "runnerDigest",
+      "executionManifestDigest",
       "model",
       "inference",
       "environment",
@@ -150,6 +151,10 @@ export function createWikiSkillBenchmarkPlan(input = {}) {
     schema: WIKISKILL_BENCHMARK_PLAN_SCHEMA,
     gitCommit,
     runnerDigest: sha(input.runnerDigest, "runnerDigest"),
+    executionManifestDigest: sha(
+      input.executionManifestDigest,
+      "executionManifestDigest",
+    ),
     model: Object.freeze({
       checkpoint: string(input.model.checkpoint, "model checkpoint"),
       digest: sha(input.model.digest, "model digest"),
@@ -178,6 +183,57 @@ export function createWikiSkillBenchmarkPlan(input = {}) {
   });
 }
 
+export function verifyWikiSkillBenchmarkPlan(plan) {
+  exactKeys(
+    plan,
+    [
+      "schema",
+      "gitCommit",
+      "runnerDigest",
+      "executionManifestDigest",
+      "model",
+      "inference",
+      "environment",
+      "datasets",
+      "toolDigest",
+      "apiDigest",
+      "promptDigest",
+      "skillDigest",
+      "wikiDigest",
+      "seedSchedule",
+      "bootstrapSamples",
+      "planDigest",
+    ],
+    "benchmark plan",
+  );
+  if (plan.schema !== WIKISKILL_BENCHMARK_PLAN_SCHEMA)
+    throw new TypeError("benchmark plan schema is invalid");
+  const recreated = createWikiSkillBenchmarkPlan({
+    gitCommit: plan.gitCommit,
+    runnerDigest: plan.runnerDigest,
+    executionManifestDigest: plan.executionManifestDigest,
+    model: plan.model,
+    inference: plan.inference,
+    environment: plan.environment,
+    datasets: plan.datasets.map(({ id, version, digest: value, splitIds }) => ({
+      id,
+      version,
+      digest: value,
+      splitIds,
+    })),
+    toolDigest: plan.toolDigest,
+    apiDigest: plan.apiDigest,
+    promptDigest: plan.promptDigest,
+    skillDigest: plan.skillDigest,
+    wikiDigest: plan.wikiDigest,
+    seedSchedule: plan.seedSchedule,
+    bootstrapSamples: plan.bootstrapSamples,
+  });
+  if (canonical(recreated) !== canonical(plan))
+    throw new Error("benchmark plan digest mismatch");
+  return recreated;
+}
+
 function normalizeArm(arm, name) {
   exactKeys(
     arm,
@@ -232,20 +288,12 @@ function mean(values) {
 }
 
 export function buildWikiSkillBenchmarkReport({ plan, runs } = {}) {
-  if (
-    !plan ||
-    plan.schema !== WIKISKILL_BENCHMARK_PLAN_SCHEMA ||
-    !DIGEST.test(plan.planDigest ?? "")
-  )
-    throw new TypeError("a canonical benchmark plan is required");
-  const expectedPlanDigest = digest(
-    WIKISKILL_BENCHMARK_PLAN_SCHEMA,
-    Object.fromEntries(
-      Object.entries(plan).filter(([key]) => key !== "planDigest"),
-    ),
-  );
-  if (expectedPlanDigest !== plan.planDigest)
-    throw new Error("benchmark plan digest mismatch");
+  try {
+    plan = verifyWikiSkillBenchmarkPlan(plan);
+  } catch (cause) {
+    if (cause?.message === "benchmark plan digest mismatch") throw cause;
+    throw new TypeError("a canonical benchmark plan is required", { cause });
+  }
   if (!Array.isArray(runs) || runs.length !== plan.seedSchedule.length)
     throw new TypeError("runs must exactly cover the seed schedule");
   const expectedCases = new Map(
@@ -383,7 +431,23 @@ export function buildWikiSkillBenchmarkReport({ plan, runs } = {}) {
   });
 }
 
-export async function executeWikiSkillBenchmark({ plan, runner } = {}) {
+export function verifyWikiSkillBenchmarkReport({ plan, report } = {}) {
+  const verifiedPlan = verifyWikiSkillBenchmarkPlan(plan);
+  if (!report || report.schema !== WIKISKILL_BENCHMARK_REPORT_SCHEMA)
+    throw new TypeError("a canonical benchmark report is required");
+  const recreated = buildWikiSkillBenchmarkReport({
+    plan: verifiedPlan,
+    runs: report.runs,
+  });
+  if (canonical(recreated) !== canonical(report))
+    throw new Error("benchmark report digest mismatch");
+  return recreated;
+}
+
+export async function executeWikiSkillBenchmarkProtocolFixture({
+  plan,
+  runner,
+} = {}) {
   if (
     !plan ||
     plan.schema !== WIKISKILL_BENCHMARK_PLAN_SCHEMA ||

package/src/lib/goal-assess.js

@@ -62,15 +62,17 @@ export function buildAssessPrompt(goal, transcript = {}) {
     `RUN RESULT:\n${finalText || "(no final text)"}`,
     "",
     "Reply with ONLY a JSON object (no prose, no code fence) of this shape:",
-    "{",
-    '  "advanced": true|false,            // did this run move the goal forward?',
-    '  "progress": <0-100 or null>,        // your estimate of new overall progress, or null to leave unchanged',
-    '  "keyResults": [                     // updates for specific key results (omit if none)',
-    '    {"id": "<kr-id>", "current": <number or null>, "done": true|false}',
-    "  ],",
-    '  "note": "<one short sentence summarizing what changed>",',
-    '  "concerns": ["<short concern>", ...]   // anything blocking/at-risk (omit if none)',
-    "}",
+    JSON.stringify({
+      advanced: false,
+      progress: null,
+      keyResults: [{ id: "<kr-id>", current: null, done: false }],
+      note: "<one short sentence summarizing what changed>",
+      concerns: [],
+    }),
+    "Set advanced to true only if this run moved the goal forward; otherwise false.",
+    "Set progress to an estimated number from 0 to 100, or null to leave it unchanged.",
+    "Each keyResults entry uses a real key-result id, a numeric current value or null, and a boolean done. Omit keyResults if there are no updates.",
+    "Include short strings in concerns for blocking or at-risk items; omit concerns if there are none.",
   ].join("\n");
 }
 
@@ -218,7 +220,12 @@ export async function assessGoalProgress({
   let reply;
   try {
     reply = await chat(prompt);
-  } catch {
+  } catch (error) {
+    if (
+      error?.code === "CC_AGENT_EVOLUTION_INGRESS_FAILED" ||
+      error?.runtimeLedgerPersistence === true
+    )
+      throw error;
     return { assessment: null, goal };
   }
   const assessment = parseAssessment(reply);

package/src/lib/interactive-planner.js

@@ -96,6 +96,11 @@ export class CLIInteractivePlanner extends EventEmitter {
       };
     } catch (err) {
       session.status = PlanSessionStatus.FAILED;
+      if (
+        err?.runtimeLedgerPersistence === true ||
+        err?.code === "CC_AGENT_EVOLUTION_INGRESS_FAILED"
+      )
+        throw err;
       return {
         sessionId,
         status: session.status,
@@ -345,7 +350,10 @@ Keep plans concise (3-8 steps). Use appropriate tools for each step.`;
       { role: "user", content: prompt },
     ]);
 
-    const content = response?.message?.content || response?.content || "";
+    const content =
+      typeof response === "string"
+        ? response
+        : response?.message?.content || response?.content || "";
     const jsonText = firstBalancedJson(content, "{");
     if (!jsonText) {
       throw new Error("Failed to parse plan from LLM response");

package/src/lib/iteration-budget.js

@@ -45,13 +45,24 @@ export class IterationBudget {
    * Resolve the budget limit from config/env/default.
    * Priority: CC_ITERATION_BUDGET env > default
    */
-  static resolveLimit() {
+  static resolveLimit(fallback = DEFAULT_BUDGET) {
     const env = process.env.CC_ITERATION_BUDGET;
     if (env) {
       const parsed = parseInt(env, 10);
       if (!isNaN(parsed) && parsed > 0) return parsed;
     }
-    return DEFAULT_BUDGET;
+    return fallback;
+  }
+
+  /** Interactive work can continue until completion; explicit caps still win. */
+  static forRun({ maxTurns, continuous = false } = {}) {
+    return new IterationBudget({
+      limit: Number.isFinite(maxTurns)
+        ? maxTurns === 0
+          ? Infinity
+          : Math.max(1, Math.floor(maxTurns))
+        : IterationBudget.resolveLimit(continuous ? Infinity : DEFAULT_BUDGET),
+    });
   }
 
   /** Total iteration limit. */
@@ -141,6 +152,9 @@ export class IterationBudget {
    * @returns {string}
    */
   toSummary() {
+    if (!Number.isFinite(this._limit)) {
+      return `Iteration budget: ${this._consumed} iterations used (no turn limit).`;
+    }
     const pct = Math.round(this.percentage() * 100);
     return (
       `Iteration budget: ${this._consumed}/${this._limit} (${pct}%). ` +

package/src/lib/micro-compact.js

@@ -9,6 +9,8 @@
  * Pure → unit-testable.
  */
 
+import { compactReadFileResult } from "./read-file-page.js";
+
 const DEFAULT_KEEP_RECENT = 6; // last N messages kept verbatim
 const DEFAULT_MAX_TOOL_CHARS = 400; // trim older tool results longer than this
 
@@ -44,7 +46,8 @@ export function microCompact(messages, opts = {}) {
         ? fullMarker
         : "…[trimmed]".slice(0, maxChars);
     const head = content.slice(0, Math.max(0, maxChars - marker.length));
-    const compactedContent = `${head}${marker}`;
+    const compactedContent =
+      compactReadFileResult(content, maxChars) || `${head}${marker}`;
     trimmed += 1;
     saved += content.length - compactedContent.length;
     return {

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/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 });