chainlesschain 0.166.86 → 0.166.88

package/src/commands/eval.js

@@ -14,6 +14,8 @@ import path from "path";
 import { fileURLToPath } from "url";
 import { runEvalSuite } from "../lib/eval/runner.js";
 import { getSuite } from "../lib/eval/tasks.js";
+import { verifyAgentTerminal } from "../lib/eval/stream-terminal.js";
+import { persistVerify01Receipts } from "../lib/eval/verify01-execution.js";
 import executionBroker from "../lib/process-execution-broker/index.js";
 import {
   TelemetryRecorder,
@@ -48,57 +50,6 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // This file is src/commands/eval.js → the CLI entry is bin/chainlesschain.js.
 const BIN = path.resolve(__dirname, "..", "..", "bin", "chainlesschain.js");
 
-function verifyAgentTerminal(output) {
-  try {
-    const events = output
-      .split(/\r?\n/u)
-      .filter((line) => line.trim())
-      .map((line) => JSON.parse(line));
-    const results = events.filter((event) => event?.type === "result");
-    const terminal = results[0];
-    const usage = terminal?.usage;
-    const normalizedUsage =
-      usage &&
-      [
-        usage.input_tokens,
-        usage.output_tokens,
-        usage.cache_read_input_tokens,
-        usage.cache_creation_input_tokens,
-      ].every((value) => Number.isSafeInteger(value) && value >= 0)
-        ? {
-            inputTokens: usage.input_tokens,
-            outputTokens: usage.output_tokens,
-            cacheReadInputTokens: usage.cache_read_input_tokens,
-            cacheCreationInputTokens: usage.cache_creation_input_tokens,
-          }
-        : null;
-    return {
-      terminalVerified:
-        results.length === 1 &&
-        events.at(-1) === terminal &&
-        terminal.subtype === "success" &&
-        terminal.is_error === false &&
-        !events.some((event) => event?.type === "error"),
-      observedFallback: events.some((event) =>
-        ["provider_fallback", "model_fallback"].includes(event?.subtype),
-      ),
-      usage: normalizedUsage,
-      totalCostUsd:
-        Number.isFinite(terminal?.total_cost_usd) &&
-        terminal.total_cost_usd >= 0
-          ? terminal.total_cost_usd
-          : null,
-    };
-  } catch {
-    return {
-      terminalVerified: false,
-      observedFallback: null,
-      usage: null,
-      totalCostUsd: null,
-    };
-  }
-}
-
 /**
  * Kill an agent child AND its tool grandchildren. A bare child.kill("SIGTERM")
  * only reaches the direct child (and on Windows TerminateProcess never reaches
@@ -142,7 +93,7 @@ function killAgentTree(child) {
  * workspace. acceptEdits lets it write files without an interactive prompt.
  */
 function makeHeadlessRunAgent(opts = {}) {
-  return function runAgent({ prompt, cwd, timeoutMs }) {
+  return function runAgent({ prompt, cwd, timeoutMs, costBudgetUsd }) {
     return new Promise((resolve) => {
       let args;
       if (opts._argv) {
@@ -163,6 +114,9 @@ function makeHeadlessRunAgent(opts = {}) {
         if (opts.model) args.push("--model", opts.model);
         if (opts.provider) args.push("--provider", opts.provider);
         if (opts.ephemeral === true) args.push("--ephemeral");
+        if (opts.sandboxMode) args.push("--sandbox-mode", opts.sandboxMode);
+        if (Number.isFinite(costBudgetUsd) && costBudgetUsd >= 0)
+          args.push("--max-budget-usd", String(costBudgetUsd));
       }
       const child = _deps.spawn(process.execPath, args, {
         cwd,
@@ -272,6 +226,26 @@ export function registerEvalCommand(program, { logger } = {}) {
       "Run the reliability eval suite (self-checking coding tasks) and report the task-success rate",
     )
     .option("--suite <name>", "Suite to run", "builtin")
+    .option("--plan-dir <directory>", "Frozen VERIFY-01 plan bundle")
+    .option("--plan-digest <digest>", "Externally pinned frozen plan digest")
+    .option("--review <file>", "Independent setup/check review configuration")
+    .option("--review-digest <digest>", "Review digest pinned before execution")
+    .option(
+      "--review-root <directory>",
+      "Trusted evaluator source root outside the task project",
+    )
+    .option(
+      "--project-root <directory>",
+      "Actual checkout of the frozen project commit",
+    )
+    .option(
+      "--samples <ids>",
+      "Selected frozen sample IDs; unselected samples remain missing",
+    )
+    .option(
+      "--evidence-dir <directory>",
+      "Keep frozen-suite raw process output and complete diffs outside compact Eval history",
+    )
     .option("--model <model>", "Model for the agent runs")
     .option("--provider <provider>", "Provider for the agent runs")
     .option("--json", "Output the summary as JSON")
@@ -381,21 +355,54 @@ export function registerEvalCommand(program, { logger } = {}) {
       let tasks;
       let comparison;
       try {
-        tasks = _deps.getSuite(options.suite);
-        comparison = createEvalComparison({
-          suite: options.suite,
-          corpusDigest: evalDigest(
-            fs.readFileSync(new URL("../lib/eval/tasks.js", import.meta.url)),
-          ),
-          provider: options.provider,
-          model: options.model,
-          context: options.comparisonContext
-            ? readComparisonContext(options.comparisonContext, {
-                provider: options.provider,
-                model: options.model,
-              })
-            : null,
+        tasks = _deps.getSuite(options.suite, {
+          verify01: {
+            planDir: options.planDir,
+            planDigest: options.planDigest,
+            reviewFile: options.review,
+            reviewDigest: options.reviewDigest,
+            reviewRoot: options.reviewRoot,
+            projectRoot: options.projectRoot,
+            sampleIds: options.samples,
+            provider: options.provider,
+            model: options.model,
+          },
         });
+        if (tasks.verification && !/^[a-f0-9]{40}$/u.test(options.label || ""))
+          throw new Error(
+            "frozen suite requires --label <40-character tested CLI source SHA>; this differs from the task project checkout SHA",
+          );
+        if (tasks.verification)
+          tasks.verification.executionSource = {
+            declaredCommit: options.label,
+            identityVerified: false,
+            declarationOnly: true,
+            entryDigest: evalDigest(fs.readFileSync(BIN)),
+          };
+        if (tasks.verification && !options.evidenceDir)
+          throw new Error(
+            "frozen suite requires --evidence-dir to retain raw execution material",
+          );
+        if (tasks.verification && options.comparisonContext)
+          throw new Error(
+            "frozen suite comparison is bound by its plan; --comparison-context cannot override it",
+          );
+        comparison =
+          tasks.verification?.comparison ||
+          createEvalComparison({
+            suite: options.suite,
+            corpusDigest: evalDigest(
+              fs.readFileSync(new URL("../lib/eval/tasks.js", import.meta.url)),
+            ),
+            provider: options.provider,
+            model: options.model,
+            context: options.comparisonContext
+              ? readComparisonContext(options.comparisonContext, {
+                  provider: options.provider,
+                  model: options.model,
+                })
+              : null,
+          });
       } catch (err) {
         log.error ? log.error(err.message) : console.error(err.message);
         process.exitCode = 1;
@@ -406,6 +413,12 @@ export function registerEvalCommand(program, { logger } = {}) {
         : makeHeadlessRunAgent({
             model: options.model,
             provider: options.provider,
+            ...(tasks.verification
+              ? {
+                  ephemeral: true,
+                  sandboxMode: tasks.verification.requiredSandboxMode,
+                }
+              : {}),
           });
 
       // OTel-shaped telemetry for the run (per-task span + failure class).
@@ -414,7 +427,7 @@ export function registerEvalCommand(program, { logger } = {}) {
       const summary = await _deps.runEvalSuite(tasks, {
         runAgent,
         recorder,
-        keepWorkspaces: options.keep === true,
+        keepWorkspaces: options.keep === true || Boolean(tasks.verification),
         onResult: options.json
           ? undefined
           : (r) =>
@@ -432,6 +445,40 @@ export function registerEvalCommand(program, { logger } = {}) {
         dryRun: options.dryRun === true,
         label: options.label || null,
       });
+      if (tasks.verification) {
+        try {
+          record.verification = {
+            ...persistVerify01Receipts(
+              tasks.verification,
+              options.evidenceDir,
+              record.runId,
+            ),
+            executionStatus: options.dryRun ? "DRY_RUN" : "ATTEMPTED",
+            // Execution material for the existing collector, not an observation
+            // or an independent acceptance of the frozen population.
+            observationsCreated: false,
+            collectionReady:
+              options.dryRun !== true &&
+              record.results.every(
+                (result) =>
+                  result.executionEvidence?.terminalVerified === true &&
+                  result.executionEvidence.protocol ===
+                    EVAL_EXECUTION_PROTOCOL &&
+                  result.executionEvidence.observedFallback === false &&
+                  Number.isFinite(result.totalCostUsd) &&
+                  result.totalCostUsd >= 0 &&
+                  Array.isArray(result.unrelatedChanges) &&
+                  result.unrelatedChanges.length === 0,
+              ),
+          };
+        } catch (error) {
+          (log.error || console.error)(
+            `frozen evidence persistence failed: ${error.message}`,
+          );
+          process.exitCode = 1;
+          return;
+        }
+      }
 
       if (options.otlp) {
         try {
@@ -485,6 +532,8 @@ export function registerEvalCommand(program, { logger } = {}) {
       // Non-zero exit when not every task passed — usable as a CI gate.
       if (summary.total === 0 || summary.passed < summary.total)
         process.exitCode = 1;
+      else if (record.verification && !record.verification.collectionReady)
+        process.exitCode = 2;
     });
   return program;
 }

package/src/commands/memory.js

@@ -166,27 +166,40 @@ export function registerMemoryCommand(program) {
     .description("Show memory entries")
     .option("-n, --limit <n>", "Max entries", "20")
     .option("--category <cat>", "Filter by category")
+    .option("--page", "Return a page with a next-page cursor")
+    .option("--cursor <cursor>", "Continue a page using the same filters")
     .option("--json", "Output as JSON")
     .action(async (options) => {
       try {
         const ctx = await bootstrap({ verbose: program.opts().verbose });
         const service = await resolveCanonicalMemory(ctx);
         if (!ctx.db && !service.decision.canonical) {
-          logger.error("Database not available");
-          process.exit(1);
+          throw new Error("Database not available");
         }
-        const entries = service.decision.canonical
-          ? await service.list({
-              limit: Math.max(1, parseInt(options.limit) || 20),
-              category: options.category,
-            })
-          : listMemory(ctx.db.getDatabase(), {
-              limit: Math.max(1, parseInt(options.limit) || 20),
-              category: options.category,
-            });
+        const paged = Boolean(options.page || options.cursor !== undefined);
+        if (paged && !service.decision.canonical) {
+          throw new Error(
+            "Paged memory listing requires canonical memory mode",
+          );
+        }
+        if (options.cursor !== undefined && !options.cursor.trim()) {
+          throw new Error("Pagination cursor must not be empty");
+        }
+        const query = {
+          limit: Math.max(1, parseInt(options.limit) || 20),
+          category: options.category,
+        };
+        const page = paged
+          ? await service.listPage({ ...query, cursor: options.cursor })
+          : null;
+        const entries = page
+          ? page.entries
+          : service.decision.canonical
+            ? await service.list(query)
+            : listMemory(ctx.db.getDatabase(), query);
 
         if (options.json) {
-          console.log(JSON.stringify(entries, null, 2));
+          console.log(JSON.stringify(page || entries, null, 2));
         } else if (entries.length === 0) {
           logger.info("No memory entries. Use 'memory add' to create one.");
         } else {
@@ -206,11 +219,17 @@ export function registerMemoryCommand(program) {
             logger.log(`    ${chalk.gray(e.created_at)}`);
           }
         }
-
-        await shutdown();
+        if (!options.json && page?.nextCursor) {
+          logger.log(`Next page cursor: ${page.nextCursor}`);
+          logger.log(
+            "Use 'memory show --cursor <cursor>' with the same category and limit.",
+          );
+        }
       } catch (err) {
         logger.error(`Failed: ${err.message}`);
-        process.exit(1);
+        process.exitCode = 1;
+      } finally {
+        await shutdown();
       }
     });
 

package/src/commands/sandbox.js

@@ -5,6 +5,7 @@
 
 import chalk from "chalk";
 import { intArg } from "../lib/cli-arg.js";
+import { describeExecutionSupport } from "../lib/execution-support.js";
 import ora from "ora";
 import { logger } from "../lib/logger.js";
 import { bootstrap, shutdown } from "../runtime/bootstrap.js";
@@ -132,6 +133,7 @@ export function registerSandboxCommand(program, dependencies = {}) {
           availability,
           host: dependencies.host,
         });
+        report.support = describeExecutionSupport({ capabilityReport: report });
 
         if (options.json) {
           console.log(JSON.stringify(report, null, 2));
@@ -144,6 +146,13 @@ export function registerSandboxCommand(program, dependencies = {}) {
             `  Backend: ${report.backend.engine || "none"} (${report.backend.availabilityChecked ? (report.backend.available ? "available" : "unavailable") : "not probed"})`,
           );
           logger.log(`  Status:  ${report.status}`);
+          logger.log(
+            `  I/O:     ${report.support.io.stdin} stdin; captured stdout/stderr`,
+          );
+          logger.log(`  Permission source: ${report.support.permissionSource}`);
+          logger.log(
+            `  Persistent network revocation: ${report.support.persistentNetworkRevocation.status} (${report.support.persistentNetworkRevocation.reason || "configured"})`,
+          );
           logger.log(
             `  Execution observed: ${report.execution.observed ? "yes" : "no"}`,
           );

package/src/data/changelog.json

@@ -1,6 +1,32 @@
 {
   "source": "CHANGELOG.md",
   "releases": [
+    {
+      "productVersion": null,
+      "cliVersion": "0.166.88",
+      "cliVersions": ["0.166.88"],
+      "date": null,
+      "title": "",
+      "sections": [
+        {
+          "heading": "Added - cc CLI 0.166.88: reviewed acceptance packs and host evidence import",
+          "body": "- Generate byte-pinned setup/check scripts for all 36 frozen tasks, including\n  behavior mutants, bounded Linux Docker execution and raw acceptance receipts.\n- Import IDE and first-run evidence through existing Eval/outcome contracts,\n  requiring input acceptance, terminal state, drained exit and complete file diffs.\n  Explicit failures stay failures; missing cost and identity attestation stay unknown.\n- Pair VS Code `0.37.133` and JetBrains `0.4.151` with CLI `0.166.88` for optional\n  ordered protocol capture. Full container, GUI, provider and billing acceptance\n  remain open; the frozen 36+9 samples remain `NOT_RUN`."
+        }
+      ]
+    },
+    {
+      "productVersion": null,
+      "cliVersion": "0.166.87",
+      "cliVersions": ["0.166.87"],
+      "date": null,
+      "title": "",
+      "sections": [
+        {
+          "heading": "Added - cc CLI 0.166.87: October model contracts and indexed memory queries",
+          "body": "- Add exact GPT-6.1 Sol and Claude Sonnet 5.5 profiles, model-specific cache\n  pricing, Responses reasoning/output validation and reviewed catalog drift checks.\n- Push memory list filters and limits into authority-bound query indexes, retain\n  stable snapshot pagination and rebuild corrupted derived indexes from authority.\n  Upgraded index descriptors require compatible readers; older readers fail closed.\n- Add a reviewed frozen CLI evaluation entry with isolated project snapshots,\n  independent acceptance scripts and raw execution evidence. Real provider/IDE\n  evaluation and billing acceptance remain separate from fixture validation.\n- Support explicit cooperative Linux cgroup2 ownership cleanup after supervisor\n  loss, preserving quarantine when kernel identity or durable settlement is unknown.\n- Verify Codex 0.160.0 native protocol and pinned MCP reference-server recovery\n  without expanding the production external-agent admission allowlist.\n- Pair VS Code `0.37.132` and JetBrains `0.4.150` with CLI `0.166.87` for live\n  capability diagnostics, strict CLI identity and bounded slow-start draft handling."
+        }
+      ]
+    },
     {
       "productVersion": null,
       "cliVersion": "0.166.86",

package/src/lib/causal-observability.js

@@ -7,7 +7,11 @@
  */
 
 import crypto from "node:crypto";
-import { PRICE_TABLE, priceRollup } from "./llm-pricing.js";
+import {
+  PRICE_TABLE,
+  priceRollup,
+  normalizePricingTerms,
+} from "./llm-pricing.js";
 import {
   projectUsagePricingContext,
   mergeUsagePricingBucket,
@@ -267,50 +271,7 @@ function normalizePricingTable(table = PRICE_TABLE) {
         result.exact = entry.exact;
       }
       if (Object.hasOwn(entry, "terms")) {
-        const terms = entry.terms;
-        const nonNegative = (value) => {
-          if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
-            throw new Error("invalid pricing multiplier");
-          return value;
-        };
-        assertKnownOwnKeys(
-          terms,
-          new Set([
-            "cacheReadMultiplier",
-            "cacheWriteMultiplier",
-            "longContext",
-            "serviceMultipliers",
-          ]),
-          "pricing terms",
-        );
-        assertKnownOwnKeys(
-          terms.longContext,
-          new Set(["threshold", "inputMultiplier", "outputMultiplier"]),
-          "pricing long context",
-        );
-        const threshold = nonNegative(terms.longContext.threshold);
-        if (!Number.isSafeInteger(threshold))
-          throw new Error("invalid pricing threshold");
-        assertKnownOwnKeys(
-          terms.serviceMultipliers,
-          new Set(["standard", "default", "auto", "batch", "flex", "fast"]),
-          "pricing service multipliers",
-        );
-        result.terms = {
-          cacheReadMultiplier: nonNegative(terms.cacheReadMultiplier),
-          cacheWriteMultiplier: nonNegative(terms.cacheWriteMultiplier),
-          longContext: {
-            threshold,
-            inputMultiplier: nonNegative(terms.longContext.inputMultiplier),
-            outputMultiplier: nonNegative(terms.longContext.outputMultiplier),
-          },
-          serviceMultipliers: Object.fromEntries(
-            Object.entries(terms.serviceMultipliers).map(([key, value]) => [
-              key,
-              nonNegative(value),
-            ]),
-          ),
-        };
+        result.terms = normalizePricingTerms(entry.terms);
       }
       return result;
     });

package/src/lib/context-memory-kernel/durable-memory-port.js

@@ -21,6 +21,16 @@ import {
 } from "@chainlesschain/context-memory-kernel";
 import { withFileLock } from "../with-file-lock.js";
 import { getHomeDir } from "../paths.js";
+import { resolve } from "node:path";
+import {
+  compareMemoryRows,
+  decodeListCursor,
+  encodeListCursor,
+  listCursorBinding,
+  matchesListQuery,
+  normalizeListQuery,
+  pageLimit,
+} from "./memory-query-index.js";
 
 const STORE_SCHEMA = "chainlesschain.cli-context-memory-store/v1";
 const DEFAULT_MAX_STORE_BYTES = 64 * 1024 * 1024;
@@ -292,19 +302,48 @@ export class DurableJsonMemoryPort {
     );
   }
 
-  async listRecords({ includeTombstones = false } = {}) {
+  async listRecords(options = {}) {
+    const query = normalizeListQuery(options);
     const records = await this.query();
     return records
-      .filter(
-        (record) =>
-          includeTombstones || !["deleted", "purged"].includes(record.state),
-      )
-      .sort(
-        (left, right) =>
-          right.importance - left.importance ||
-          right.updatedAt.localeCompare(left.updatedAt, "en") ||
-          left.memoryId.localeCompare(right.memoryId, "en"),
+      .filter((record) => matchesListQuery(record, query))
+      .sort(compareMemoryRows)
+      .slice(
+        0,
+        options.limit == null
+          ? undefined
+          : Math.max(1, Number(options.limit) || 20),
+      );
+  }
+
+  async listPage(options = {}) {
+    const query = normalizeListQuery(options);
+    const count = pageLimit(options.limit);
+    return this._locked(() => {
+      const state = this._readUnlocked();
+      const binding = listCursorBinding(
+        resolve(this.filePath),
+        state.digest,
+        query,
       );
+      const after = decodeListCursor(options.cursor, binding);
+      const matches = Object.values(state.records)
+        .filter(
+          (record) =>
+            matchesListQuery(record, query) &&
+            (!after || compareMemoryRows(record, after) > 0),
+        )
+        .sort(compareMemoryRows);
+      const records = matches.slice(0, count);
+      return {
+        records,
+        storeRevision: state.storeRevision,
+        nextCursor:
+          matches.length > count
+            ? encodeListCursor(binding, records.at(-1))
+            : null,
+      };
+    });
   }
 
   async commit({ record, event, reconciliation }, expectedRevision = 0) {