chainlesschain 0.166.46 → 0.166.48

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-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,

package/src/lib/evolution/evidence-backed-wiki-maintainer.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { assertEvolutionContentContainsNoKnownSecrets } from "./evolution-evidence-projector.js";
 
 export const WIKI_STATE_SCHEMA = "chainlesschain.evolution-wiki-state/v1";
 export const WIKI_EVIDENCE_SCHEMA = "chainlesschain.evolution-wiki-evidence/v1";
@@ -126,6 +127,105 @@ function assertMetadataOnly(value, path = "data") {
   }
 }
 
+function assertWikiPlaintextSafe(value) {
+  const isDecisionDigestRef = (candidate) =>
+    typeof candidate === "string" &&
+    candidate.startsWith("decision:") &&
+    DIGEST.test(candidate.slice("decision:".length));
+  const isBoundMaintenanceRequestMapKey = (path, key, child) =>
+    path.length === 1 &&
+    path[0] === "maintenanceRequests" &&
+    MAINTENANCE_REQUEST_ID.test(key) &&
+    child &&
+    typeof child === "object" &&
+    !Array.isArray(child) &&
+    DIGEST.test(child.requestDigest ?? "") &&
+    key === `wiki-maintenance:${child.requestDigest.slice("sha256:".length)}`;
+  const isBoundProposalDecisionEvidence = (path, key, child) =>
+    path.length === 1 &&
+    path[0] === "evidence" &&
+    isDecisionDigestRef(key) &&
+    child &&
+    typeof child === "object" &&
+    !Array.isArray(child) &&
+    child.kind === "proposal-decision" &&
+    child.ref === key;
+  const isProposalDecisionEvidenceRecord = (path, item) =>
+    path.length === 2 &&
+    path[0] === "evidence" &&
+    isDecisionDigestRef(path[1]) &&
+    item?.kind === "proposal-decision" &&
+    item.ref === path[1];
+  const isBoundProposalDecisionArtifactRef = (path, item, key, child) =>
+    key === "artifactRef" &&
+    isProposalDecisionEvidenceRecord(path, item) &&
+    DIGEST.test(item.data?.releaseDigest ?? "") &&
+    child ===
+      `artifact://${item.tenantId}/trusted/${item.data.releaseDigest.slice("sha256:".length)}`;
+  const isBoundProposalDecisionReceiptRef = (path, item, key, child) =>
+    path.length === 4 &&
+    path[0] === "skillImpact" &&
+    path[2] === "decisions" &&
+    path[3] === "[]" &&
+    key === "receiptRef" &&
+    DIGEST.test(item.candidateId ?? "") &&
+    child === `decision:${item.candidateId}`;
+  const isProposalImpactCandidateSubject = (path, item, key, child) =>
+    path.length === 2 &&
+    path[0] === "evolutionLog" &&
+    path[1] === "[]" &&
+    key === "subjectId" &&
+    item.type === "proposal-impact-recorded" &&
+    DIGEST.test(child ?? "");
+  const isBoundProtocolValue = (path, item, key, child) =>
+    (key.endsWith("Digest") && DIGEST.test(child ?? "")) ||
+    (key === "candidateId" && DIGEST.test(child ?? "")) ||
+    isProposalImpactCandidateSubject(path, item, key, child) ||
+    isBoundProposalDecisionReceiptRef(path, item, key, child) ||
+    isBoundProposalDecisionArtifactRef(path, item, key, child) ||
+    (isProposalDecisionEvidenceRecord(path, item) &&
+      key === "ref" &&
+      child === path[1]) ||
+    (key === "revisionId" && REVISION_ID.test(child ?? "")) ||
+    (key === "requestId" && MAINTENANCE_REQUEST_ID.test(child ?? ""));
+  const inspect = (item, path = []) => {
+    if (typeof item === "string") {
+      assertEvolutionContentContainsNoKnownSecrets(item);
+    } else if (Array.isArray(item)) {
+      item.forEach((child) => inspect(child, [...path, "[]"]));
+    } else if (item && typeof item === "object") {
+      for (const [key, child] of Object.entries(item)) {
+        // Maintenance requests are stored under their validated, digest-bound
+        // request ID. The map key is opaque protocol metadata, not model text;
+        // inspecting random hash bytes as prose can falsely match PII patterns.
+        // Restrict the exemption to the state map and inspect its complete
+        // record so an untrusted lookalike key cannot bypass this boundary.
+        if (
+          !isBoundMaintenanceRequestMapKey(path, key, child) &&
+          !isBoundProposalDecisionEvidence(path, key, child)
+        )
+          assertEvolutionContentContainsNoKnownSecrets(key);
+        // Protocol metadata can carry random hash bytes that accidentally match
+        // a PII detector. Every exemption is bound to its state path, schema and
+        // sibling fields; prose and lookalikes still go through the detector.
+        if (isBoundProtocolValue(path, item, key, child)) continue;
+        if (["string", "number"].includes(typeof child))
+          assertEvolutionContentContainsNoKnownSecrets(`${key}=${child}`);
+        inspect(child, [...path, key]);
+      }
+    }
+  };
+  try {
+    inspect(value);
+  } catch (cause) {
+    const error = new Error("Wiki revision contains secret or PII plaintext", {
+      cause,
+    });
+    error.code = "WIKI_MAINTAINER_SECRET_LEAK";
+    throw error;
+  }
+}
+
 export function createEmptyWikiState(tenantId) {
   return freeze({
     schema: WIKI_STATE_SCHEMA,
@@ -301,6 +401,36 @@ function evidenceUsable(item, effectiveAt) {
   );
 }
 
+// Corroboration needs distinct content AND distinct trust domains. Counting
+// either set alone lets the same observation be repeated under new identities.
+// A bounded bipartite matching also handles policies requiring >2 sources,
+// where min(unique contents, unique domains) can still overcount independence.
+function independentSourceCount(evidence) {
+  const domains = new Map();
+  for (const item of evidence) {
+    if (!domains.has(item.trustDomain))
+      domains.set(item.trustDomain, new Set());
+    domains.get(item.trustDomain).add(item.sourceDigest);
+  }
+  const matchedSources = new Map();
+  const match = (domain, visited) => {
+    for (const source of domains.get(domain)) {
+      if (visited.has(source)) continue;
+      visited.add(source);
+      if (
+        !matchedSources.has(source) ||
+        match(matchedSources.get(source), visited)
+      ) {
+        matchedSources.set(source, domain);
+        return true;
+      }
+    }
+    return false;
+  };
+  for (const domain of domains.keys()) match(domain, new Set());
+  return matchedSources.size;
+}
+
 function rebuildDerivedState(state, effectiveAt, descriptor) {
   const dependents = {};
   for (const pattern of Object.values(state.patterns)) {
@@ -352,7 +482,10 @@ function rebuildDerivedState(state, effectiveAt, descriptor) {
       pattern.status = WIKI_PATTERN_STATUS.STALE;
     } else if (negative.length > 0 || pattern.contradicts.length > 0)
       pattern.status = WIKI_PATTERN_STATUS.CONTRADICTED;
-    else if (hasGrader || domains.length >= descriptor.minCorroboratingSources)
+    else if (
+      hasGrader ||
+      independentSourceCount(positive) >= descriptor.minCorroboratingSources
+    )
       pattern.status = WIKI_PATTERN_STATUS.CORROBORATED;
     else pattern.status = WIKI_PATTERN_STATUS.HYPOTHESIS;
     pattern.trustDomains = domains;
@@ -735,6 +868,10 @@ export class EvidenceBackedWikiMaintainer {
         revisionId: state.revisionId,
       };
     }
+    // Trusted inputs do not make a model's derived output safe to persist.
+    // Inspect the complete outgoing state, including reasons, index and log,
+    // before publishing any revision artifact. Share the Raw/Skill policy.
+    assertWikiPlaintextSafe(state);
     const stateDigest = hash(state);
     const revision = freeze({
       ...revisionPayload,
@@ -742,6 +879,22 @@ export class EvidenceBackedWikiMaintainer {
       stateDigest,
       state: freeze(clone(state)),
     });
+    // Derivation may await a model or another worker. Re-resolve through the
+    // trusted evidence boundary immediately before writing: prior read success
+    // is not permission to publish after revocation, deletion, or expiry. A
+    // changed but valid envelope requires fresh derivation, never a silent swap.
+    for (const ref of refs) {
+      const current = verifyEvidence(
+        await this._ports.resolveEvidence(ref),
+        this.descriptor.tenantId,
+        ref,
+      );
+      if (current.envelopeDigest !== evidenceByRef.get(ref).envelopeDigest) {
+        const error = new Error("Wiki evidence changed during derivation");
+        error.code = "WIKI_MAINTAINER_EVIDENCE_CHANGED";
+        throw error;
+      }
+    }
     const committed = await this._ports.commitRevision(
       freeze({ expectedStateDigest: priorStateDigest, revision }),
     );