chainlesschain 0.166.45 → 0.166.47

package/src/lib/eval/runner.js

@@ -8,8 +8,9 @@
  * runEvalSuite gives each task a fresh temp workspace, runs `setup` to lay down
  * the starting files, hands `prompt` to the agent (via an injected `runAgent` so
  * the harness is testable without a live LLM), then runs `check` to decide
- * pass/fail deterministically. The score is the fraction of tasks whose check
- * passed — a verifiable success-rate metric, per the plan's north star.
+ * artifacts deterministically. Task success requires both a passing artifact
+ * check and an explicitly successful execution; failed runs can retain useful
+ * artifact-check results without inflating the reliability score.
  *
  * The real `cc eval` command wires `runAgent` to a headless `cc agent -p` run;
  * unit tests inject a fake runAgent to exercise scoring/report logic offline.
@@ -146,9 +147,15 @@ export async function runEvalSuite(tasks, opts = {}) {
         // and still run check() (the workspace may be partially done).
         rec.error = `agent error: ${agentErr.message}`;
       }
-      rec.executionSucceeded = agentResult?.ok === true && !rec.error;
+      rec.executionSucceeded =
+        agentResult?.ok === true &&
+        !rec.error &&
+        (agentResult.error == null || agentResult.error === "");
       rec.agentOk = rec.executionSucceeded;
       rec.executionEvidence = agentResult?.executionEvidence || null;
+      if (agentResult?.evaluationMetrics !== undefined) {
+        rec.evaluationMetrics = agentResult.evaluationMetrics;
+      }
       if (!rec.executionSucceeded && !rec.error) {
         rec.error = `agent error: ${agentResult?.error || "execution did not report success"}`;
       }

package/src/lib/evolution/agent-evolution-ingress.js

@@ -23,6 +23,14 @@ export const AGENT_EVOLUTION_INGRESS_SCHEMA =
 export const AGENT_EVOLUTION_INGRESS_FAILED_CODE =
   "CC_AGENT_EVOLUTION_INGRESS_FAILED";
 
+const RESPONSE_CACHE_RECORD_SCHEMA =
+  "chainlesschain.model-response-cache/v2";
+const LEGACY_RESPONSE_CACHE_RECORD_SCHEMA =
+  "chainlesschain.model-response-cache/v1";
+const RESPONSE_CACHE_IDENTIFIER_BINDING_SCHEMA =
+  "chainlesschain.model-response-cache-identifier-binding/v1";
+const HEX_ALPHA = "abcdefghijklmnop";
+
 const INGRESSES = new WeakSet();
 const CORE_EVENT_KINDS = new Map([
   ["tool-executing", "tool-requested"],
@@ -101,6 +109,22 @@ function digest(value) {
   return `sha256:${crypto.createHash("sha256").update(canonical(value)).digest("hex")}`;
 }
 
+function cacheIdentifierBinding(kind, value) {
+  const input = requiredString(value, `Cache ${kind}`);
+  const bytes = crypto
+    .createHash("sha256")
+    .update(
+      `${RESPONSE_CACHE_IDENTIFIER_BINDING_SCHEMA}\0${kind}\0${input}`,
+      "utf8",
+    )
+    .digest();
+  let encoded = "";
+  for (const byte of bytes) {
+    encoded += HEX_ALPHA[byte >>> 4] + HEX_ALPHA[byte & 0x0f];
+  }
+  return encoded;
+}
+
 function timestamp(value, label) {
   const date = new Date(value);
   if (!Number.isFinite(date.getTime()) || date.toISOString() !== value) {
@@ -263,10 +287,21 @@ export function createAgentEvolutionIngress({
           throw new Error("Cache receipt requires a recorded model response");
         const payload = cacheRecord
           ? {
-              schema: "chainlesschain.model-response-cache/v1",
-              requestKey: evidence.requestKey,
-              sourceRunId: descriptor.runId,
-              sourceEventId: lastModelResponse.eventId,
+              schema: RESPONSE_CACHE_RECORD_SCHEMA,
+              identifierBindingSchema:
+                RESPONSE_CACHE_IDENTIFIER_BINDING_SCHEMA,
+              requestKeyBinding: cacheIdentifierBinding(
+                "request key",
+                evidence.requestKey,
+              ),
+              sourceRunIdBinding: cacheIdentifierBinding(
+                "source Run ID",
+                descriptor.runId,
+              ),
+              sourceEventIdBinding: cacheIdentifierBinding(
+                "source event ID",
+                lastModelResponse.eventId,
+              ),
               responseEvent: clone(lastModelResponse.event),
             }
           : (modelRequest ?? clone(evidence));
@@ -433,6 +468,18 @@ export function createAgentEvolutionIngress({
             );
           const projection = resolved.bundle.modelProjection;
           const record = projection.content;
+          const legacyRecord =
+            record?.schema === LEGACY_RESPONSE_CACHE_RECORD_SCHEMA;
+          const currentRecord =
+            record?.schema === RESPONSE_CACHE_RECORD_SCHEMA &&
+            record.identifierBindingSchema ===
+              RESPONSE_CACHE_IDENTIFIER_BINDING_SCHEMA &&
+            record.requestKeyBinding ===
+              cacheIdentifierBinding("request key", requestKey) &&
+            record.sourceRunIdBinding ===
+              cacheIdentifierBinding("source Run ID", receipt.runId) &&
+            typeof record.sourceEventIdBinding === "string" &&
+            /^[a-p]{64}$/u.test(record.sourceEventIdBinding);
           if (
             resolved.verification.verified !== true ||
             resolved.verification.tenantId !== descriptor.tenantId ||
@@ -440,16 +487,21 @@ export function createAgentEvolutionIngress({
             projection.visibility !== "model-visible" ||
             projection.truncated ||
             projection.injectionFindings.length !== 0 ||
-            record?.schema !== "chainlesschain.model-response-cache/v1" ||
-            record.requestKey !== requestKey ||
-            record.sourceRunId !== receipt.runId ||
+            (!currentRecord &&
+              (!legacyRecord ||
+                record.requestKey !== requestKey ||
+                record.sourceRunId !== receipt.runId)) ||
             record.responseEvent?.type !== "response-complete"
           )
             throw new Error(
               "Cache response projection is not safe or request-bound",
             );
           const responseEvent = loaded.events.find(
-            (item) => item.eventId === record.sourceEventId,
+            (item) =>
+              legacyRecord
+                ? item.eventId === record.sourceEventId
+                : cacheIdentifierBinding("source event ID", item.eventId) ===
+                  record.sourceEventIdBinding,
           );
           if (
             responseEvent?.data?.evidenceKind !== "response-completed" ||

package/src/lib/evolution/agent-evolution-runtime-composition.js

@@ -11,6 +11,7 @@ import {
 import {
   EvolutionEvidenceBundleVerifier,
   EvolutionEvidenceProjector,
+  EvolutionEvidenceReader,
 } from "./evolution-evidence-projector.js";
 import { EvolutionArtifactPorts } from "./evolution-artifact-ports.js";
 import {
@@ -18,12 +19,17 @@ import {
   createEvolutionLedgerFileBackend,
 } from "./evolution-ledger-file-backend.js";
 import { EvolutionRunLedgerAdapter } from "./evolution-run-ledger-adapter.js";
+import { createEvolutionRunWikiEvidenceResolver } from "./evolution-run-wiki-evidence-resolver.js";
+import { WikiMaintainerLedgerAdapter } from "./wiki-maintainer-ledger-adapter.js";
+import { EvidenceBackedWikiMaintainer } from "./evidence-backed-wiki-maintainer.js";
+import { createWikiEvidenceCommitGuard } from "./wiki-evidence-commit-guard.js";
 import { EvolutionWorkbenchMetricsLedgerAdapter } from "./evolution-workbench-metrics-ledger-adapter.js";
 import { EvolutionReleaseTrainLedgerAdapter } from "./evolution-release-train-ledger-adapter.js";
 import { WikiSkillProposalLedgerAdapter } from "./wiki-skill-proposal-ledger-adapter.js";
 import { EvolutionReleaseTrainStageOutputLedgerAdapter } from "./evolution-release-train-stage-output-ledger-adapter.js";
 import { createEvolutionReleaseTrainDomainStages } from "./evolution-release-train-domain-stages.js";
 import { createEvolutionReleaseTrain } from "./evolution-release-train.js";
+import { createEvolutionEvalRuntimeStageConfiguration } from "./evolution-eval-runtime-composition.js";
 import { captureSkillOutcomeSourceCatalogAuthority } from "./skill-outcome-source-catalog-authority.js";
 import {
   captureAgentEvolutionIngress,
@@ -62,6 +68,36 @@ const SKILL_OUTCOME_CATALOG_ENTRY_KEYS = new Set(["runId", "skillNames"]);
 const MAX_SKILL_OUTCOME_SOURCES = 128;
 const RELEASE_TRAIN_STAGE_KEYS = new Set(["plan", "stages"]);
 const RELEASE_TRAIN_DOMAIN_KEYS = new Set(["plan", "domain"]);
+const WIKI_MAINTENANCE_KEYS = new Set([
+  "principalEnvelope",
+  "schemaPolicies",
+  "readAuthorities",
+  "commitCoordinator",
+  "maintainer",
+]);
+const WIKI_READ_AUTHORITY_KEYS = new Set([
+  "evidenceState",
+  "principalResolver",
+  "accessPolicy",
+]);
+const WIKI_COMMIT_COORDINATOR_KEYS = new Set(["acquireCurrentEvidence"]);
+const WIKI_MAINTAINER_KEYS = new Set([
+  "maintainerModel",
+  "rulesDigest",
+  "minCorroboratingSources",
+  "derive",
+]);
+const WIKI_STAGE_KEYS = new Set(["request", "usage"]);
+const DOMAIN_STAGE_KEYS = new Set([
+  "wiki-maintain",
+  "propose",
+  "candidate",
+  "eval",
+  "review",
+  "pilot",
+  "promotion",
+  "wiki-impact",
+]);
 
 function exactRecord(value, keys, label) {
   if (
@@ -191,6 +227,7 @@ export function createAgentEvolutionRuntimeComposition({
   evidenceIdGenerator,
   ingressIdGenerator,
   wikiMaintenanceProducer = null,
+  wikiMaintenance: wikiMaintenanceInput = null,
   releaseTrain: releaseTrainInput = null,
   completionTriggerKind,
   secure = true,
@@ -199,7 +236,18 @@ export function createAgentEvolutionRuntimeComposition({
   random,
   lockTimeoutMs,
   witnessMaximumBytes,
+  ledgerV2: ledgerV2Input = null,
 } = {}) {
+  const ledgerV2 =
+    ledgerV2Input === null
+      ? null
+      : Object.freeze({
+          ...exactRecord(
+            ledgerV2Input,
+            new Set(["createBackend", "minimumRetainedUntil"]),
+            "ledger v2 production composition",
+          ),
+        });
   const tenantId = identifier(tenantIdInput, "tenantId");
   const runId = identifier(runIdInput, "runId");
   const audience = identifier(audienceInput, "audience");
@@ -218,6 +266,79 @@ export function createAgentEvolutionRuntimeComposition({
     "authorities.artifact",
   );
   const clock = normalizeClock(clockInput);
+  let wikiConfiguration = null;
+  if (wikiMaintenanceInput !== null) {
+    const input = exactRecord(
+      wikiMaintenanceInput,
+      WIKI_MAINTENANCE_KEYS,
+      "wikiMaintenance",
+    );
+    const readers = exactRecord(
+      input.readAuthorities,
+      WIKI_READ_AUTHORITY_KEYS,
+      "wikiMaintenance.readAuthorities",
+    );
+    const maintainer = exactRecord(
+      input.maintainer,
+      WIKI_MAINTAINER_KEYS,
+      "wikiMaintenance.maintainer",
+    );
+    const coordinator = exactRecord(
+      input.commitCoordinator,
+      WIKI_COMMIT_COORDINATOR_KEYS,
+      "wikiMaintenance.commitCoordinator",
+    );
+    if (
+      utilTypes.isAsyncFunction(coordinator.acquireCurrentEvidence) ||
+      utilTypes.isGeneratorFunction(coordinator.acquireCurrentEvidence)
+    ) {
+      throw new TypeError("Wiki commit coordinator must be synchronous");
+    }
+    const commitCoordinator = Object.freeze({
+      acquireCurrentEvidence: capture(
+        coordinator,
+        "acquireCurrentEvidence",
+        "Wiki commit coordinator",
+      ),
+    });
+    if (
+      !Number.isSafeInteger(maintainer.minCorroboratingSources) ||
+      maintainer.minCorroboratingSources < 2 ||
+      maintainer.minCorroboratingSources > 128
+    ) {
+      throw new TypeError(
+        "Wiki corroboration threshold must be between 2 and 128",
+      );
+    }
+    wikiConfiguration = Object.freeze({
+      principalEnvelope: input.principalEnvelope,
+      schemaPolicies: input.schemaPolicies,
+      commitCoordinator,
+      descriptor: Object.freeze({
+        tenantId,
+        evolutionRunId: runId,
+        maintainerModel: maintainer.maintainerModel,
+        rulesDigest: maintainer.rulesDigest,
+        minCorroboratingSources: maintainer.minCorroboratingSources,
+      }),
+      derive: capture(maintainer, "derive", "Wiki maintainer"),
+      evidenceState: captureAuthority(
+        readers.evidenceState,
+        "resolve",
+        "Wiki evidence state",
+      ),
+      principalResolver: captureAuthority(
+        readers.principalResolver,
+        "resolve",
+        "Wiki principal resolver",
+      ),
+      accessPolicy: captureAuthority(
+        readers.accessPolicy,
+        "authorize",
+        "Wiki access policy",
+      ),
+    });
+  }
   if (
     typeof evidenceIdGenerator !== "function" ||
     utilTypes.isProxy(evidenceIdGenerator)
@@ -342,6 +463,15 @@ export function createAgentEvolutionRuntimeComposition({
     ledgerAuthority: authorities.ledger,
     witnessAuthority: authorities.witness,
     artifactResolver: ledgerArtifactResolver,
+    ...(ledgerV2 === null
+      ? {}
+      : {
+          manifestV2: {
+            ...ledgerV2,
+            artifactPorts,
+            descriptor: { tenantId, artifactTenantId: tenantId, audience },
+          },
+        }),
     secure,
     clock,
     ...(fsImpl === undefined ? {} : { fsImpl }),
@@ -384,6 +514,66 @@ export function createAgentEvolutionRuntimeComposition({
     ledgerArtifactResolver,
     now: clock,
   });
+  let wikiMaintenance = null;
+  let wikiMaintainer = null;
+  if (wikiConfiguration !== null) {
+    const evidenceReader = new EvolutionEvidenceReader({
+      attestationVerifier: ports.attestationVerifier,
+      evidenceState: wikiConfiguration.evidenceState,
+      principalResolver: wikiConfiguration.principalResolver,
+      accessPolicy: wikiConfiguration.accessPolicy,
+      now: () => new Date(clock()),
+    });
+    const wikiEvidence = createEvolutionRunWikiEvidenceResolver({
+      runAdapter,
+      evidenceAdapter,
+      evidenceReader,
+      principalEnvelope: wikiConfiguration.principalEnvelope,
+      schemaPolicies: wikiConfiguration.schemaPolicies,
+    });
+    const wikiAdapter = new WikiMaintainerLedgerAdapter({
+      descriptor: {
+        tenantId,
+        artifactTenantId: tenantId,
+        evolutionRunId: runId,
+        audience,
+        purpose: "evolution-ledger",
+      },
+      artifactPorts,
+      ledger: backend.ledger,
+      ledgerArtifactResolver,
+    });
+    const wikiCommit = createWikiEvidenceCommitGuard({
+      wikiAdapter,
+      commitCoordinator: wikiConfiguration.commitCoordinator,
+      principalEnvelope: wikiConfiguration.principalEnvelope,
+      clock,
+    });
+    wikiMaintainer = new EvidenceBackedWikiMaintainer({
+      descriptor: wikiConfiguration.descriptor,
+      policy: {
+        trustedProjectionRead: true,
+        rawEvidenceRead: false,
+        activeSkillWrite: false,
+        shell: false,
+        network: false,
+        secretRead: false,
+      },
+      ports: {
+        ...wikiAdapter.maintainerPorts({
+          resolveEvidence: wikiEvidence.resolveEvidence,
+          derive: wikiConfiguration.derive,
+        }),
+        commitRevision: wikiCommit.commitRevision,
+      },
+    });
+    // The host receives only scoped maintenance and authenticated Wiki reads,
+    // never a Raw store, caller-supplied bundle, or write/approval capability.
+    wikiMaintenance = Object.freeze({
+      maintain: Object.freeze(wikiMaintainer.maintain.bind(wikiMaintainer)),
+      loadWiki: Object.freeze(() => wikiAdapter.loadWiki()),
+    });
+  }
   const skillOutcomeReaders = new Map();
   const createSkillOutcomeReader = Object.freeze((skillNameInput) => {
     const skillName = identifier(skillNameInput, "skillName");
@@ -415,6 +605,14 @@ export function createAgentEvolutionRuntimeComposition({
       releaseTrainKeys,
       "releaseTrain",
     );
+    if (
+      wikiMaintainer !== null &&
+      !Object.hasOwn(releaseTrainConfig, "domain")
+    ) {
+      throw new TypeError(
+        "authorized Wiki maintenance requires production release train domain stages",
+      );
+    }
     if (
       releaseTrainConfig.plan?.tenantId !== tenantId ||
       typeof releaseTrainConfig.plan?.skillId !== "string"
@@ -463,8 +661,35 @@ export function createAgentEvolutionRuntimeComposition({
         ledger: backend.ledger,
         ledgerArtifactResolver,
       });
+      let domain = releaseTrainConfig.domain;
+      exactRecord(domain, DOMAIN_STAGE_KEYS, "releaseTrain.domain");
+      domain = {
+        ...domain,
+        eval: createEvolutionEvalRuntimeStageConfiguration({
+          configuration: domain.eval,
+          tenantId,
+          runId,
+          artifactPorts,
+          ledger: backend.ledger,
+          ledgerArtifactResolver,
+          audience,
+          now: clock,
+        }),
+      };
+      if (wikiMaintainer !== null) {
+        exactRecord(domain, DOMAIN_STAGE_KEYS, "releaseTrain.domain");
+        const wikiStage = exactRecord(
+          domain["wiki-maintain"],
+          WIKI_STAGE_KEYS,
+          "authorized wiki-maintain stage",
+        );
+        domain = {
+          ...domain,
+          "wiki-maintain": { ...wikiStage, maintainer: wikiMaintainer },
+        };
+      }
       stages = createEvolutionReleaseTrainDomainStages({
-        domain: releaseTrainConfig.domain,
+        domain,
         proposalLedger,
         outputLedger,
       });
@@ -513,6 +738,15 @@ export function createAgentEvolutionRuntimeComposition({
         ledgerAuthority: cacheSourceAuthorities.ledger,
         witnessAuthority: cacheSourceAuthorities.witness,
         artifactResolver: sourceResolver,
+        ...(ledgerV2 === null
+          ? {}
+          : {
+              manifestV2: {
+                ...ledgerV2,
+                artifactPorts: sourcePorts,
+                descriptor: { tenantId, artifactTenantId: tenantId, audience },
+              },
+            }),
         secure,
         clock,
         ...(fsImpl === undefined ? {} : { fsImpl }),
@@ -553,6 +787,7 @@ export function createAgentEvolutionRuntimeComposition({
     runId,
     evolutionIngress,
     createSkillOutcomeReader,
+    wikiMaintenance,
     loadRun: Object.freeze(() => runAdapter.load()),
     ledgerDescriptor: backend.descriptor,
     storage,

package/src/lib/evolution/agent-model-projection.js

@@ -11,6 +11,8 @@ const MESSAGE_KEYS = new Set([
   "tool_call_id",
   "name",
   "_thinkingBlocks",
+  "_openaiReasoningItems",
+  "_openaiReasoningSummary",
 ]);
 const OPAQUE_BLOCK_SCHEMA =
   "chainlesschain.evolution-agent-opaque-transport-block/v1";
@@ -124,6 +126,9 @@ function opaqueKind(value, path) {
   if (/^messages\.\d+\._thinkingBlocks\.\d+$/u.test(path)) {
     return thinkingBlock(value) ? value.type : null;
   }
+  if (/^messages\.\d+\._openaiReasoningItems\.\d+$/u.test(path)) {
+    return openAIReasoningItem(value) ? "openai_reasoning" : null;
+  }
   return null;
 }
 
@@ -142,13 +147,70 @@ function isOpaqueBlock(value) {
   return (
     exactKeys(value, OPAQUE_BLOCK_KEYS) &&
     value.schema === OPAQUE_BLOCK_SCHEMA &&
-    ["image", "thinking", "redacted_thinking"].includes(value.kind) &&
+    ["image", "thinking", "redacted_thinking", "openai_reasoning"].includes(
+      value.kind,
+    ) &&
     /^sha256:[a-f0-9]{64}$/u.test(value.digest) &&
     Number.isSafeInteger(value.byteLength) &&
     value.byteLength > 0
   );
 }
 
+function openAIReasoningItem(value) {
+  if (
+    !value ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    ![Object.prototype, null].includes(Object.getPrototypeOf(value)) ||
+    value.type !== "reasoning" ||
+    Object.keys(value).some(
+      (key) =>
+        !["type", "id", "encrypted_content", "summary", "status"].includes(key),
+    )
+  ) {
+    return null;
+  }
+  if (
+    Object.hasOwn(value, "id") &&
+    (typeof value.id !== "string" ||
+      !/^[A-Za-z0-9._:-]{1,256}$/u.test(value.id))
+  ) {
+    return null;
+  }
+  if (
+    Object.hasOwn(value, "encrypted_content") &&
+    (typeof value.encrypted_content !== "string" ||
+      value.encrypted_content.length < 1 ||
+      value.encrypted_content.length > 256 * 1024 ||
+      !/^[\x21-\x7e]+$/u.test(value.encrypted_content))
+  ) {
+    return null;
+  }
+  if (Object.hasOwn(value, "summary")) {
+    if (
+      !Array.isArray(value.summary) ||
+      value.summary.length < 1 ||
+      value.summary.length > 16 ||
+      value.summary.some(
+        (part) =>
+          !exactKeys(part, new Set(["type", "text"])) ||
+          part.type !== "summary_text" ||
+          typeof part.text !== "string" ||
+          part.text.length > 8192,
+      )
+    ) {
+      return null;
+    }
+  }
+  if (
+    Object.hasOwn(value, "status") &&
+    !["completed", "in_progress", "incomplete"].includes(value.status)
+  ) {
+    return null;
+  }
+  return Object.keys(value).length > 1 ? value : null;
+}
+
 function assertContentBlock(value, path, allowOpaqueTransportBlocks) {
   if (allowOpaqueTransportBlocks && isOpaqueBlock(value)) return;
   if (
@@ -214,6 +276,36 @@ function assertMessageShape(message, index, allowOpaqueTransportBlocks) {
       }
     });
   }
+  if (Object.hasOwn(message, "_openaiReasoningItems")) {
+    if (
+      message.role !== "assistant" ||
+      !Array.isArray(message._openaiReasoningItems) ||
+      !message._openaiReasoningItems.length ||
+      message._openaiReasoningItems.length > 16
+    ) {
+      throw new TypeError(
+        "OpenAI reasoning replay requires bounded assistant items",
+      );
+    }
+    message._openaiReasoningItems.forEach((item, itemIndex) => {
+      if (
+        !(allowOpaqueTransportBlocks && isOpaqueBlock(item)) &&
+        !openAIReasoningItem(item)
+      ) {
+        throw new TypeError(
+          `OpenAI reasoning item at messages.${index}._openaiReasoningItems.${itemIndex} is unsupported`,
+        );
+      }
+    });
+  }
+  if (
+    Object.hasOwn(message, "_openaiReasoningSummary") &&
+    (message.role !== "assistant" ||
+      typeof message._openaiReasoningSummary !== "string" ||
+      message._openaiReasoningSummary.length > 8192)
+  ) {
+    throw new TypeError("OpenAI reasoning summary is unsupported");
+  }
 }
 
 // Capture before the first await. Accessors, proxies and exotic objects cannot
@@ -326,6 +418,10 @@ function textPath(path, allowStructuredArgumentText = true) {
     /^messages\.\d+\._thinkingBlocks\.\d+\.(?:thinking|signature|data)$/u.test(
       path,
     ) ||
+    /^messages\.\d+\._openaiReasoningItems\.\d+\.(?:encrypted_content|summary\.\d+\.text)$/u.test(
+      path,
+    ) ||
+    /^messages\.\d+\._openaiReasoningSummary$/u.test(path) ||
     (allowStructuredArgumentText
       ? /^messages\.\d+\.tool_calls\.\d+\.function\.arguments(?:\.|$)/u.test(
           path,