chainlesschain 0.166.128 → 0.166.129

package/src/data/changelog.json

@@ -1,6 +1,19 @@
 {
   "source": "CHANGELOG.md",
   "releases": [
+    {
+      "productVersion": null,
+      "cliVersion": "0.166.129",
+      "cliVersions": ["0.166.129"],
+      "date": "2026-10-28",
+      "title": "",
+      "sections": [
+        {
+          "heading": "Fixed - cc CLI 0.166.129: independent change review and Codex support evidence (candidate, 2026-10-28)",
+          "body": "- Give opted-in hermetic change review its own request context and tool journal, preserving original requirements, shared request limits, permissions and cancellation. Missing review usage blocks further calls; review is not independent task acceptance.\n- Centralize experimental Codex App Server support, versioned schema probes and CI targets. Keep default-off routing and the existing experimental allowlist; probe-only 0.160.0 and 0.164.0 do not imply production admission.\n- Verify concurrent thread recovery with explicit database recency pagination on Linux, Windows and macOS. Retain documented limitations for default rollout scanning and legacy creation-time pagination.\n- Retain published child dependencies. Candidate publication requires exact-commit CLI CI and Strict Sandbox across all configured systems, GitHub Actions OIDC publication and public artifact readback. Historical task and native acceptance remain separately reported."
+        }
+      ]
+    },
     {
       "productVersion": null,
       "cliVersion": "0.166.128",

package/src/lib/codex-app-server-adapter.js

@@ -1,13 +1,17 @@
 import { EventEmitter } from "node:events";
-
-export const CODEX_APP_SERVER_PROTOCOL = "codex-app-server-experimental-v1";
-export const CODEX_APP_SERVER_FEATURE_FLAG = "CC_EXPERIMENTAL_CODEX_APP_SERVER";
-export const CODEX_APP_SERVER_COMPATIBILITY_MATRIX = Object.freeze([
-  Object.freeze({ version: "0.149.0" }),
-  Object.freeze({ version: "0.150.0" }),
-  Object.freeze({ version: "0.150.1" }),
-  Object.freeze({ version: "0.154.0" }),
-]);
+import {
+  CODEX_APP_SERVER_PROTOCOL,
+  CODEX_APP_SERVER_FEATURE_FLAG,
+  CODEX_APP_SERVER_FALLBACK_PROTOCOL,
+  CODEX_APP_SERVER_COMPATIBILITY_MATRIX,
+  getCodexAppServerSupport,
+  parseCodexVersion,
+} from "./codex-app-server-support.js";
+export {
+  CODEX_APP_SERVER_PROTOCOL,
+  CODEX_APP_SERVER_FEATURE_FLAG,
+  CODEX_APP_SERVER_COMPATIBILITY_MATRIX,
+} from "./codex-app-server-support.js";
 
 function adapterError(code, message, details = {}) {
   const error = new Error(message);
@@ -17,17 +21,10 @@ function adapterError(code, message, details = {}) {
   return error;
 }
 
-function parseVersion(value) {
-  const match = String(value || "")
-    .trim()
-    .match(/^(?:codex(?:-cli)?\s+)?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/u);
-  return match ? match.slice(1).map(Number).join(".") : null;
-}
-
 export function isCodexAppServerVersionCompatible(version, matrix = []) {
-  const parsed = parseVersion(version);
+  const parsed = parseCodexVersion(version);
   if (!parsed || !Array.isArray(matrix) || matrix.length === 0) return false;
-  return matrix.some((entry) => parseVersion(entry?.version) === parsed);
+  return matrix.some((entry) => parseCodexVersion(entry?.version) === parsed);
 }
 
 function projectNotification(notification) {
@@ -182,11 +179,16 @@ export class CodexAppServerAdapter extends EventEmitter {
       productionCritical: false,
       featureFlag: CODEX_APP_SERVER_FEATURE_FLAG,
       enabled: this.enabled,
+      support: getCodexAppServerSupport(this.upstreamVersion),
+      compatibilitySource:
+        this.compatibilityMatrix === CODEX_APP_SERVER_COMPATIBILITY_MATRIX
+          ? "manifest"
+          : "override",
       versionCompatible: isCodexAppServerVersionCompatible(
         this.upstreamVersion,
         this.compatibilityMatrix,
       ),
-      fallback: "codex-exec-jsonl-v1",
+      fallback: CODEX_APP_SERVER_FALLBACK_PROTOCOL,
     });
   }
 
@@ -302,6 +304,7 @@ export class CodexAppServerAdapter extends EventEmitter {
     const buildResult = (terminalEvent) =>
       Object.freeze({
         protocol: CODEX_APP_SERVER_PROTOCOL,
+        support: claims.support,
         threadId: activeThreadId,
         turnId: activeTurnId,
         terminal: terminalEvent.terminal,
@@ -388,13 +391,23 @@ export class CodexAppServerAdapter extends EventEmitter {
         throw adapterError(
           "CC_CODEX_APP_SERVER_SUBMISSION_UNKNOWN",
           "Codex App Server turn submission outcome is unknown; fallback was suppressed to prevent duplicate effects",
-          { cause: error },
+          {
+            cause: error,
+            protocol: CODEX_APP_SERVER_PROTOCOL,
+            fallbackSuppressed: true,
+            support: claims.support,
+          },
         );
       }
       throw adapterError(
         "CC_CODEX_APP_SERVER_FAILED_AFTER_ADMISSION",
         "Codex App Server failed after the turn was admitted; fallback was suppressed to prevent duplicate effects",
-        { cause: error },
+        {
+          cause: error,
+          protocol: CODEX_APP_SERVER_PROTOCOL,
+          fallbackSuppressed: true,
+          support: claims.support,
+        },
       );
     } finally {
       clearTimeout(timer);
@@ -412,7 +425,8 @@ export class CodexAppServerAdapter extends EventEmitter {
     const result = await this.fallback({ prompt, ...options });
     return Object.freeze({
       ...result,
-      protocol: "codex-exec-jsonl-v1",
+      protocol: CODEX_APP_SERVER_FALLBACK_PROTOCOL,
+      support: getCodexAppServerSupport(this.upstreamVersion),
       fallback: true,
       fallbackReason: reason,
       authoritative: false,

package/src/lib/codex-app-server-support.js

@@ -0,0 +1,91 @@
+// Configured probe coverage is not evidence that a workflow passed. Admission
+// stays separate from both probe configuration and the experimental allowlist.
+export const CODEX_APP_SERVER_PROTOCOL = "codex-app-server-experimental-v1";
+export const CODEX_APP_SERVER_FEATURE_FLAG = "CC_EXPERIMENTAL_CODEX_APP_SERVER";
+export const CODEX_APP_SERVER_FALLBACK_PROTOCOL = "codex-exec-jsonl-v1";
+
+export const CODEX_APP_SERVER_SUPPORT = Object.freeze({
+  revision: "2026-10-28",
+  defaultEnabled: false,
+  productionAdmitted: false,
+  platforms: Object.freeze([
+    Object.freeze({ platform: "linux", runner: "ubuntu-latest" }),
+    Object.freeze({ platform: "windows", runner: "windows-latest" }),
+    Object.freeze({ platform: "macos", runner: "macos-latest" }),
+  ]),
+  versions: Object.freeze([
+    ...["0.149.0", "0.150.0", "0.150.1", "0.154.0"].map((version) =>
+      Object.freeze({
+        version,
+        experimentalAllowed: true,
+        compatibilityProbeConfigured: true,
+        schemaAndTurnProbeConfigured: false,
+      }),
+    ),
+    ...["0.160.0", "0.164.0"].map((version) =>
+      Object.freeze({
+        version,
+        experimentalAllowed: false,
+        compatibilityProbeConfigured: false,
+        schemaAndTurnProbeConfigured: true,
+      }),
+    ),
+  ]),
+});
+
+export const CODEX_APP_SERVER_COMPATIBILITY_MATRIX = Object.freeze(
+  CODEX_APP_SERVER_SUPPORT.versions
+    .filter((entry) => entry.experimentalAllowed)
+    .map(({ version }) => Object.freeze({ version })),
+);
+
+export const CODEX_APP_SERVER_SCHEMA_PROBE_VERSIONS = Object.freeze(
+  CODEX_APP_SERVER_SUPPORT.versions
+    .filter((entry) => entry.schemaAndTurnProbeConfigured)
+    .map((entry) => entry.version),
+);
+// Keep the original default for callers that do not specify a probe version.
+export const CODEX_APP_SERVER_SCHEMA_PROBE_VERSION =
+  CODEX_APP_SERVER_SCHEMA_PROBE_VERSIONS[0];
+
+export function parseCodexVersion(value) {
+  const match = String(value || "")
+    .trim()
+    .match(/^(?:codex(?:-cli)?\s+)?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/u);
+  return match ? match.slice(1).join(".") : null;
+}
+
+export function getCodexAppServerSupport(version) {
+  const upstreamVersion = parseCodexVersion(version);
+  const entry = CODEX_APP_SERVER_SUPPORT.versions.find(
+    (candidate) => candidate.version === upstreamVersion,
+  );
+  return Object.freeze({
+    manifestRevision: CODEX_APP_SERVER_SUPPORT.revision,
+    upstreamVersion,
+    knownVersion: Boolean(entry),
+    defaultEnabled: CODEX_APP_SERVER_SUPPORT.defaultEnabled,
+    productionAdmitted: CODEX_APP_SERVER_SUPPORT.productionAdmitted,
+    experimentalAllowed: entry?.experimentalAllowed === true,
+    compatibilityProbeConfigured: entry?.compatibilityProbeConfigured === true,
+    schemaAndTurnProbeConfigured: entry?.schemaAndTurnProbeConfigured === true,
+  });
+}
+
+export function codexAppServerCiMatrices() {
+  const entries = (predicate) => ({
+    include: CODEX_APP_SERVER_SUPPORT.versions
+      .filter(predicate)
+      .flatMap(({ version }) =>
+        CODEX_APP_SERVER_SUPPORT.platforms.map(({ platform, runner }) => ({
+          platform,
+          runner,
+          codex_version: version,
+        })),
+      ),
+  });
+  return {
+    compatibility: entries((entry) => entry.compatibilityProbeConfigured),
+    schema: entries((entry) => entry.schemaAndTurnProbeConfigured),
+  };
+}

package/src/lib/coding-change-review-context.js

@@ -0,0 +1,258 @@
+import { isDeepStrictEqual } from "node:util";
+import {
+  DURABLE_SYSTEM_MESSAGE_KINDS,
+  SESSION_MESSAGE_PROVENANCE_FIELD,
+  encodePersistedMessage,
+  getDurableSystemMessageProvenance,
+  isRuntimeOnlySessionMessage,
+} from "./session-message-provenance.js";
+
+function snapshot(message) {
+  const copy = encodePersistedMessage(message);
+  if (!copy || typeof copy !== "object" || Array.isArray(copy)) {
+    throw new TypeError("Review context requires plain message objects");
+  }
+  return copy;
+}
+
+function hasContent(message) {
+  return (
+    (typeof message.content === "string" &&
+      message.content.trim().length > 0) ||
+    (Array.isArray(message.content) && message.content.length > 0)
+  );
+}
+
+function mergeAdjacentUsers(messages) {
+  const projected = [];
+  for (const message of messages) {
+    const previous = projected.at(-1);
+    if (previous?.role !== "user" || message.role !== "user") {
+      projected.push(message);
+      continue;
+    }
+    // Message-level metadata can have provider-specific scope. Dropping it or
+    // attaching it to a larger user turn could change meaning or authority.
+    if (
+      [previous, message].some((entry) =>
+        Object.keys(entry).some((key) => !["role", "content"].includes(key)),
+      )
+    ) {
+      throw new TypeError("Cannot safely merge review user message metadata");
+    }
+    const left = previous.content;
+    const right = message.content;
+    if (
+      ![left, right].every(
+        (content) => typeof content === "string" || Array.isArray(content),
+      )
+    ) {
+      throw new TypeError("Cannot safely merge review user message content");
+    }
+    const blocks = (content) =>
+      Array.isArray(content) ? content : [{ type: "text", text: content }];
+    previous.content =
+      typeof left === "string" && typeof right === "string"
+        ? `${left}\n\n${right}`
+        : [...blocks(left), ...blocks(right)];
+  }
+  return projected;
+}
+
+function contentSegments(content) {
+  const blocks =
+    typeof content === "string" ? [{ type: "text", text: content }] : content;
+  if (!Array.isArray(blocks))
+    throw new TypeError("Invalid review requirement content");
+  const segments = [];
+  for (const block of blocks) {
+    // Blocks with provider metadata are not interchangeable with plain text.
+    if (
+      block?.type === "text" &&
+      typeof block.text === "string" &&
+      Object.keys(block).every((key) => ["type", "text"].includes(key))
+    ) {
+      if (typeof segments.at(-1) === "string")
+        segments[segments.length - 1] += block.text;
+      else segments.push(block.text);
+    } else segments.push(block);
+  }
+  return segments;
+}
+
+function preservesContent(expected, actual, allowSuffix) {
+  const required = contentSegments(expected);
+  const supplied = contentSegments(actual);
+  if (
+    supplied.length < required.length ||
+    (!allowSuffix && supplied.length !== required.length)
+  )
+    return false;
+  return required.every((segment, index) => {
+    if (
+      allowSuffix &&
+      index === required.length - 1 &&
+      typeof segment === "string"
+    ) {
+      return (
+        typeof supplied[index] === "string" &&
+        supplied[index].startsWith(segment)
+      );
+    }
+    return isDeepStrictEqual(segment, supplied[index]);
+  });
+}
+
+function pendingCalls(messages) {
+  const pending = new Set();
+  for (const message of messages) {
+    if (message.role === "tool") {
+      if (!pending.delete(message.tool_call_id)) {
+        throw new TypeError("Review tool result has no pending call");
+      }
+      continue;
+    }
+    if (pending.size) {
+      throw new TypeError("Review tool call group is incomplete");
+    }
+    if (message.tool_calls !== undefined) {
+      if (message.role !== "assistant" || !Array.isArray(message.tool_calls)) {
+        throw new TypeError("Invalid review tool calls");
+      }
+      // Provider IDs are scoped to a tool batch, matching agentLoop. A fully
+      // settled later batch may reuse an ID without making its result orphaned.
+      const seen = new Set();
+      for (const call of message.tool_calls) {
+        if (typeof call?.id !== "string" || !call.id || seen.has(call.id)) {
+          throw new TypeError("Review tool call IDs must be unique strings");
+        }
+        seen.add(call.id);
+        pending.add(call.id);
+      }
+    }
+  }
+  return pending;
+}
+
+/**
+ * Request-only context for one independent review within the existing loop.
+ * The caller supplies pristine host-built task messages before compaction;
+ * unmarked system messages must already be trusted host instructions.
+ * This journal neither replaces durable history nor grants any authority.
+ */
+export class CodingChangeReviewContext {
+  #initial;
+  #journal = [];
+  #active = false;
+
+  constructor(initialMessages) {
+    // Validate the entire input without invoking accessors before inspecting it.
+    const validated = snapshot({ messages: initialMessages }).messages;
+    if (!Array.isArray(validated)) {
+      throw new TypeError("Review context requires initial task messages");
+    }
+    this.#initial = [];
+    for (const message of initialMessages) {
+      const copy = snapshot(message);
+      if (isRuntimeOnlySessionMessage(message)) continue;
+      const provenance = getDurableSystemMessageProvenance(message);
+      if (provenance) {
+        if (provenance.kind === DURABLE_SYSTEM_MESSAGE_KINDS.FORK_LINEAGE) {
+          continue;
+        }
+        throw new TypeError(
+          "Review requires original requirements before summarization",
+        );
+      }
+      if (Object.hasOwn(message, SESSION_MESSAGE_PROVENANCE_FIELD)) {
+        throw new TypeError(
+          "Review context cannot trust serialized provenance",
+        );
+      }
+      if (!["system", "user"].includes(copy.role)) continue;
+      if (!hasContent(copy) || copy.tool_calls || copy.tool_call_id) {
+        throw new TypeError("Review requirements must have valid content");
+      }
+      this.#initial.push(copy);
+    }
+    if (!this.#initial.some((message) => message.role === "user")) {
+      throw new TypeError("Review requires original user requirements");
+    }
+  }
+
+  get active() {
+    return this.#active;
+  }
+
+  activate(reviewPromptMessage) {
+    if (this.#active) return false;
+    const prompt = snapshot(reviewPromptMessage);
+    if (
+      prompt.role !== "user" ||
+      !hasContent(prompt) ||
+      prompt.tool_calls ||
+      prompt.tool_call_id
+    ) {
+      throw new TypeError("Review prompt must be a user-role instruction");
+    }
+    this.#journal = [prompt];
+    this.#active = true;
+    return true;
+  }
+
+  record(...messages) {
+    if (!this.#active) return;
+    const copies = messages.map((message) => {
+      const copy = snapshot(message);
+      if (
+        !["assistant", "tool"].includes(copy.role) &&
+        !(copy.role === "user" && isRuntimeOnlySessionMessage(message))
+      ) {
+        throw new TypeError(
+          "Review journal accepts only review responses and runtime nudges",
+        );
+      }
+      return copy;
+    });
+    const next = [...this.#journal, ...copies];
+    pendingCalls(next);
+    this.#journal = next;
+  }
+
+  /** Fail closed if request normalization or context planning dropped scope. */
+  assertRequirementsPreserved(projectedMessages) {
+    if (!this.#active) throw new TypeError("Review context is not active");
+    const supplied = snapshot({ messages: projectedMessages }).messages;
+    if (!Array.isArray(supplied))
+      throw new TypeError("Invalid review provider messages");
+    const required = mergeAdjacentUsers(this.#initial.map(snapshot));
+    for (let index = 0; index < required.length; index++) {
+      const expected = required[index];
+      const actual = supplied[index];
+      if (
+        !actual ||
+        actual.role !== expected.role ||
+        !preservesContent(
+          expected.content,
+          actual.content,
+          expected.role === "user",
+        )
+      ) {
+        throw new TypeError(
+          "Review provider context did not preserve original requirements",
+        );
+      }
+    }
+    return true;
+  }
+
+  project() {
+    if (!this.#active) throw new TypeError("Review context is not active");
+    if (pendingCalls(this.#journal).size) {
+      throw new TypeError("Review tool call group is incomplete");
+    }
+    return mergeAdjacentUsers(
+      [...this.#initial, ...this.#journal].map(snapshot),
+    );
+  }
+}

package/src/lib/coding-task-guidance.js

@@ -4,6 +4,7 @@ export const CODING_TASK_QUALITY_GUIDANCE = `Coding task quality:
 - Keep progress explanations to one or two sentences. Once the relevant API and behavior are clear, make the next tool call; resolve a remaining uncertainty with a targeted read. Put implementation code directly in write/edit tool arguments instead of rehearsing the code or repeatedly analyzing the same source in ordinary assistant text.
 - Resolve each relative import from the destination file's directory. Read back the completed file and fix newDiagnostics from write/edit results before finishing. A successful write confirms persistence, not syntax, test execution or acceptance.
 - Before finishing a regression task, map each explicit acceptance requirement to a concrete fixture, production call path and observable assertion in the deliverable. Positive and negative controls must exercise the same requested behavior and differ in the intended condition. Resolve uncovered requirements with permitted tools, or report the specific gap. Avoid mocks or alternate calls that bypass the behavior under test. Complete the current worker/request when testing cancellation and replacement.
+- Allocate limited test cases from the user's explicit requirements, not from the tests already written. A test-count cap is a prioritization budget, not permission to omit a requirement. Merge or replace equivalent cases that reach the same decision so uncovered requirements take priority. Repair known coverage gaps within the authorized scope and remaining budgets; if a gap cannot be resolved, report the task as incomplete.
 - For boundary regressions, derive expected defaults, computed values and rejection rules from the implementation or the explicit requested contract. Inject mismatched, tampered or stale input through the real entry point while keeping other prerequisites valid; verify that the fixture reaches the intended check rather than failing during setup. Compare observable results with independent expected values or authoritative state, not a helper that merely recomputes the same result.
 - Trace rejection before asserting its aftermath: a request can be rejected before registration or persistence. Check whether state stays unchanged, a failed record is saved, or an event is emitted; do not assume every rejection creates a failed task. When testing attribution, verify independently recorded identities and provenance as well as message contents; identical text can still be attributed to the wrong source.
 - Use available execution tools for a focused check when permitted. When execution tools are unavailable, inspect imports, API contracts and fixtures using the available file tools, and clearly say that tests were not run. Never describe a read-back or static check as a passing test or end-to-end verification.
@@ -17,5 +18,7 @@ Return a concise, evidence-based completion message within these tool limits.`;
 
 /** Optional runtime follow-up; contains no task-specific acceptance information. */
 export const CODING_CHANGE_REVIEW_PROMPT = `Runtime change review: the original user task, authorized scope, tools and remaining budgets still apply; this message grants no new permissions.
+Inspect the current deliverable and relevant source with the permitted tools. Build your own requirement-to-assertion account before accepting the existing implementation; earlier completion explanations are not evidence. For a negative control, keep unrelated rejection conditions valid so another guard cannot mask a missing check. Check the actual order of observable effects when an operation throws.
 Before finishing, check the changed deliverable against each explicit requirement. For regression tests, identify the concrete fixture, actual production call path and observable assertion for each requirement. Confirm that positive and negative controls reach the intended behavior with valid prerequisites and differ in the intended condition. Similar field names and unrelated rejection paths do not establish coverage.
+Derive that requirement list from the original task, not from the tests already written. If a test-count cap is reached, merge or replace redundant cases reaching the same decision to cover missing requirements within that cap. Use the remaining budget to repair an identified gap rather than treating the count cap as a scope exemption. A reported missing requirement means the task remains incomplete.
 Use permitted tools to inspect and repair any gap. Run focused checks only when execution tools are available. If a requirement remains uncovered or a check cannot be run, report that specific limitation. This review is not evidence that tests or independent acceptance passed. Give a concise final answer when finished.`;

package/src/lib/context-memory-kernel/provider-context.js

@@ -189,7 +189,12 @@ export async function prepareCanonicalProviderContext(
     };
   }
 
-  const candidateProvider = semanticCandidateProvider(options);
+  // Review can exclude recalled author/session data while retaining the exact
+  // canonical context, tool and output-token planning boundary.
+  const recallEnabled = options.contextMemoryRecall !== false;
+  const candidateProvider = recallEnabled
+    ? semanticCandidateProvider(options)
+    : null;
   const sink = String(options.contextMemorySink || `provider.${provider}`);
   const scopeAdmissions = defaultAdmissions(sessionId, options);
   const lastUser = [...messages]
@@ -211,17 +216,22 @@ export async function prepareCanonicalProviderContext(
     scopeAdmissions,
     limit: recallLimit,
   });
-  const recall = await runtime.kernel.recallMemory({
-    query,
-    sink,
-    scopeAdmissions,
-    limit: recallLimit,
-    tokenBudget: Math.max(
-      1,
-      Math.min(32_768, Number(options.contextMemoryRecallTokens) || 4096),
-    ),
-    ...(semanticCandidates === undefined ? {} : { semanticCandidates }),
-  });
+  const recall = recallEnabled
+    ? await runtime.kernel.recallMemory({
+        query,
+        sink,
+        scopeAdmissions,
+        limit: recallLimit,
+        tokenBudget: Math.max(
+          1,
+          Math.min(32_768, Number(options.contextMemoryRecallTokens) || 4096),
+        ),
+        ...(semanticCandidates === undefined ? {} : { semanticCandidates }),
+      })
+    : {
+        results: [],
+        memoryRevision: await runtime.memoryPort.getRevision(),
+      };
   const imageTransport = captureContextImageTransport(messages);
   const messageItems = adjustContextImageTokenEstimates(
     messagesToContextItems(imageTransport.messages, {