chainlesschain 0.166.76 → 0.166.78

package/src/lib/model-capabilities.js

@@ -2,6 +2,7 @@ import { canonicalDigest } from "@chainlesschain/context-memory-kernel";
 import {
   CONTEXT_WINDOWS,
   DOCUMENTED_OPENAI_MODELS,
+  DOCUMENTED_ANTHROPIC_MODELS,
   LEGACY_MODEL_PROVIDERS,
   MODEL_CAPABILITY_CATALOG_VERSION,
 } from "./model-context-catalog.js";
@@ -61,7 +62,7 @@ function deepFreeze(value) {
   return Object.freeze(value);
 }
 
-function isOfficialOpenAIBaseUrl(baseUrl) {
+function isOfficialModelBaseUrl(provider, baseUrl) {
   if (baseUrl == null || baseUrl === "") return true;
   if (typeof baseUrl !== "string") {
     throw new TypeError("baseUrl must be a string when provided");
@@ -71,7 +72,10 @@ function isOfficialOpenAIBaseUrl(baseUrl) {
     // decorations and non-default ports. Never return or hash the input URL.
     return (
       baseUrl === baseUrl.trim() &&
-      new URL(baseUrl).href === "https://api.openai.com/v1"
+      new URL(baseUrl).href ===
+        (provider === "openai"
+          ? "https://api.openai.com/v1"
+          : "https://api.anthropic.com/v1")
     );
   } catch {
     return false;
@@ -137,13 +141,17 @@ export function resolveModelCapabilityProfile({
     "contextMemoryModelWindowTokens",
     { min: 1024, max: MAX_CONTEXT_WINDOW_TOKENS },
   );
+  const catalog =
+    selectedProvider === "openai"
+      ? DOCUMENTED_OPENAI_MODELS
+      : selectedProvider === "anthropic"
+        ? DOCUMENTED_ANTHROPIC_MODELS
+        : null;
   const officialEndpoint =
-    selectedProvider === "openai" && isOfficialOpenAIBaseUrl(baseUrl);
+    Boolean(catalog) && isOfficialModelBaseUrl(selectedProvider, baseUrl);
   const documented =
-    officialEndpoint &&
-    selectedModel &&
-    Object.hasOwn(DOCUMENTED_OPENAI_MODELS, selectedModel)
-      ? DOCUMENTED_OPENAI_MODELS[selectedModel]
+    officialEndpoint && selectedModel && Object.hasOwn(catalog, selectedModel)
+      ? catalog[selectedModel]
       : null;
   const legacyOwner =
     selectedModel && Object.hasOwn(LEGACY_MODEL_PROVIDERS, selectedModel)
@@ -213,9 +221,9 @@ export function resolveModelCapabilityProfile({
       "The model's legacy catalog entry belongs to another provider and was not applied.",
     );
   }
-  if (selectedProvider === "openai" && !officialEndpoint) {
+  if (catalog && !officialEndpoint) {
     limitations.push(
-      "Official OpenAI model specifications are not applied to a custom endpoint.",
+      `Official ${selectedProvider === "openai" ? "OpenAI" : "Anthropic"} model specifications are not applied to a custom endpoint.`,
     );
   }
   if (output.requestMaxOutputTokens === null) {
@@ -234,7 +242,7 @@ export function resolveModelCapabilityProfile({
     );
   }
   if (
-    documented &&
+    documented?.advertisedMaxOutputTokens != null &&
     output.requestMaxOutputTokens > documented.advertisedMaxOutputTokens
   ) {
     limitations.push(
@@ -263,6 +271,9 @@ export function resolveModelCapabilityProfile({
     runtimeVerified: false,
     ...output,
     advertisedMaxOutputTokens: documented?.advertisedMaxOutputTokens ?? null,
+    ...(documented?.reasoningEfforts
+      ? { reasoningEfforts: [...documented.reasoningEfforts] }
+      : {}),
     sources: documented ? [...documented.sources] : [],
     limitations,
   };

package/src/lib/model-context-catalog.js

@@ -45,7 +45,7 @@ export const CONTEXT_WINDOWS = Object.freeze({
   }),
 });
 
-export const MODEL_CAPABILITY_CATALOG_VERSION = "2026-09-13";
+export const MODEL_CAPABILITY_CATALOG_VERSION = "2026-09-27";
 
 // Explicit ownership prevents a model name served by an unrelated provider
 // from silently inheriting another provider's catalog window.
@@ -97,9 +97,68 @@ export const DOCUMENTED_OPENAI_MODELS = Object.freeze({
     contextWindowTokens: 1050000,
     advertisedMaxOutputTokens: 128000,
     requiresResponsesForTools: true,
+    reasoningEfforts: Object.freeze(["low", "medium", "high", "xhigh", "max"]),
+    pricing: Object.freeze({ in: 10, out: 50 }),
     sources: Object.freeze([
       "https://developers.openai.com/api/docs/models/gpt-6-astra",
       "https://developers.openai.com/api/docs/guides/migrate-to-responses",
     ]),
   }),
+  ...Object.fromEntries(
+    [
+      ["gpt-6-sol", 2, 10],
+      ["gpt-6-luna", 0.1, 0.5],
+    ].map(([model, input, output]) => [
+      model,
+      Object.freeze({
+        contextWindowTokens: 1050000,
+        advertisedMaxOutputTokens: 128000,
+        requiresResponsesForTools: true,
+        reasoningEfforts: Object.freeze([
+          "none",
+          "low",
+          "medium",
+          "high",
+          "xhigh",
+          "max",
+        ]),
+        pricing: Object.freeze({ in: input, out: output }),
+        sources: Object.freeze([
+          `https://developers.openai.com/api/docs/models/${model}`,
+        ]),
+      }),
+    ]),
+  ),
+});
+
+export const DOCUMENTED_ANTHROPIC_MODELS = Object.freeze({
+  "claude-opus-5-5": Object.freeze({
+    contextWindowTokens: 1000000,
+    // The release notes establish the window and pricing, not an output cap.
+    advertisedMaxOutputTokens: null,
+    pricing: Object.freeze({ in: 4, out: 20 }),
+    sources: Object.freeze([
+      "https://code.claude.com/docs/en/changelog#2-1-280",
+    ]),
+  }),
+});
+
+// Request-level pricing terms shared by cost reporting and hard budget gates.
+// Never apply these tiers to a sum of multiple requests.
+export const GPT6_PRICING_TERMS = Object.freeze({
+  cacheReadMultiplier: 0.1,
+  cacheWriteMultiplier: 1.25,
+  longContext: Object.freeze({
+    threshold: 272000,
+    inputMultiplier: 2,
+    outputMultiplier: 1.5,
+  }),
+  serviceMultipliers: Object.freeze({
+    standard: 1,
+    default: 1,
+    auto: 1,
+    batch: 0.5,
+    flex: 0.5,
+    fast: 2,
+  }),
 });

package/src/lib/openai-responses.js

@@ -300,7 +300,13 @@ export function normalizeOpenAIResponsesResponse(data) {
     responseId: printableString(data.id) || null,
   };
   const usage = normalizeOpenAIResponsesUsage(data.usage);
-  if (usage) result.usage = usage;
+  if (usage)
+    result.usage = {
+      ...usage,
+      ...(typeof data.service_tier === "string"
+        ? { service_tier: data.service_tier }
+        : {}),
+    };
   return result;
 }
 

package/src/lib/orchestrator.js

@@ -141,13 +141,16 @@ export class Orchestrator extends EventEmitter {
     // Multi-path agent router
     this._router =
       options.agentRouter ||
-      (options.agents
+      (Array.isArray(options.agents?.backends)
         ? new AgentRouter({
             backends: options.agents.backends || [],
             strategy: options.agents.strategy || "round-robin",
             maxParallel: this.maxParallel,
           })
-        : AgentRouter.autoDetect({ maxParallel: this.maxParallel }));
+        : AgentRouter.autoDetect({
+            maxParallel: this.maxParallel,
+            strategy: options.agents?.strategy,
+          }));
 
     // Multi-channel notification manager
     this.notifier =
@@ -188,6 +191,9 @@ export class Orchestrator extends EventEmitter {
    */
   async addTask(description, opts = {}) {
     assertCLILegacyMutationAllowed("Orchestrator.addTask");
+    // Reject opaque external CLIs before notifications, Run creation or paid
+    // decomposition. This preflight never replaces the dispatch ingress gate.
+    this._router.assertDispatchAvailable?.();
     const task = {
       id: generateId("task"),
       description,

package/src/lib/process-execution-broker/index.js

@@ -46,6 +46,14 @@ import {
   SANDBOX_BOUNDARIES,
 } from "./platform-sandbox.js";
 import { normalizeLinuxCgroupPolicy } from "./linux-cgroup-v2.js";
+import { acquireLinuxSubreaperHelper } from "./linux-subreaper-helper.js";
+import { spawnLinuxSubreaperChild } from "./linux-subreaper-process.js";
+import {
+  assertProcessOwnershipAvailable,
+  getProcessOwnershipStatus,
+  observeProcessOwnership,
+  prepareProcessOwnership,
+} from "./process-ownership-quarantine.js";
 import {
   MACOS_MCP_LAUNCHER_INPUTS,
   isMacosMcpLauncherPackageVersion,
@@ -1187,6 +1195,7 @@ class ProcessExecutionBroker extends EventEmitter {
   _sanitizeOptions(options) {
     if (!options) return {};
     const safe = { ...options };
+    delete safe.linuxSubreaper;
     if (process.platform === "win32" && safe.shell === true) {
       safe.windowsHide = true;
     }
@@ -4479,6 +4488,7 @@ class ProcessExecutionBroker extends EventEmitter {
    * and durable evidence APIs.
    */
   beginWorkspaceTransaction(options = {}) {
+    assertProcessOwnershipAvailable();
     return this._workspaceTransactionManager(
       options.stateDir,
       options.lockDir,
@@ -4486,6 +4496,7 @@ class ProcessExecutionBroker extends EventEmitter {
   }
 
   recoverWorkspaceTransactions(options = {}) {
+    assertProcessOwnershipAvailable();
     return this._workspaceTransactionManager(
       options.stateDir,
       options.lockDir,
@@ -4499,6 +4510,10 @@ class ProcessExecutionBroker extends EventEmitter {
     ).inspect(id);
   }
 
+  getProcessOwnershipStatus() {
+    return getProcessOwnershipStatus();
+  }
+
   listWorkspaceTransactions(options = {}) {
     return this._workspaceTransactionManager(
       options.stateDir,
@@ -4507,6 +4522,7 @@ class ProcessExecutionBroker extends EventEmitter {
   }
 
   restoreWorkspaceTransaction(id, options = {}) {
+    assertProcessOwnershipAvailable();
     return this._workspaceTransactionManager(
       options.stateDir,
       options.lockDir,
@@ -4514,6 +4530,7 @@ class ProcessExecutionBroker extends EventEmitter {
   }
 
   undoWorkspaceTransactionRestore(id, options = {}) {
+    assertProcessOwnershipAvailable();
     return this._workspaceTransactionManager(
       options.stateDir,
       options.lockDir,
@@ -4569,6 +4586,7 @@ class ProcessExecutionBroker extends EventEmitter {
   }
 
   spawn(command, args, options = {}) {
+    assertProcessOwnershipAvailable();
     options = this._withAmbientProcessContext(command, options);
     const executionId = crypto.randomUUID();
     const startTime = Date.now();
@@ -4800,7 +4818,71 @@ class ProcessExecutionBroker extends EventEmitter {
         );
         auditEntry.mcpStdioExecutableIdentityDigest = admitted.identityDigest;
       }
-      proc = nativeSpawnFn(command, args, optsForSpawn);
+      if (
+        process.platform === "linux" &&
+        options.linuxSubreaper &&
+        !sandboxPlan.guarantees.includes(SANDBOX_BOUNDARIES.PROCESS_TREE)
+      ) {
+        const request = options.linuxSubreaper;
+        const stdio = optsForSpawn.stdio;
+        if (
+          !request ||
+          typeof request !== "object" ||
+          Array.isArray(request) ||
+          Object.keys(request).some((key) => key !== "graceMs") ||
+          !Number.isSafeInteger(request.graceMs) ||
+          request.graceMs < 0 ||
+          request.graceMs > 2147483647 ||
+          sandboxPlan.postSpawn.required ||
+          options.shell ||
+          optsForSpawn.shell ||
+          optsForSpawn.detached ||
+          (stdio !== undefined && stdio !== "pipe") ||
+          ["uid", "gid", "signal", "timeout", "input", "argv0"].some(
+            (key) => optsForSpawn[key] !== undefined,
+          ) ||
+          (sandboxPlan.applied && sandboxPlan.backend !== "linux-prlimit")
+        ) {
+          const error = new Error(
+            "Linux external-agent supervision cannot preserve this launch plan",
+          );
+          error.code = "EXTERNAL_AGENT_SUPERVISION_UNSUPPORTED_PLAN";
+          throw error;
+        }
+        const ownershipLease = prepareProcessOwnership(executionId);
+        let nativeEntered = false;
+        try {
+          const helper = acquireLinuxSubreaperHelper({
+            spawnSync: this._native?.spawnSync || nativeSpawnSync,
+          });
+          proc = spawnLinuxSubreaperChild(
+            command,
+            args,
+            {
+              cwd: path.resolve(optsForSpawn.cwd || cwd),
+              env: optsForSpawn.env || process.env,
+              graceMs: request.graceMs,
+              helper,
+            },
+            {
+              spawn: (...nativeArgs) => {
+                nativeEntered = true;
+                return nativeSpawnFn(...nativeArgs);
+              },
+            },
+          );
+        } catch (error) {
+          // Before native entry no process could exist. Once entered, retain
+          // the durable record even if a synchronous exception hides its handle.
+          if (!nativeEntered) ownershipLease?.settle();
+          else ownershipLease?.retain();
+          throw error;
+        }
+        auditEntry.processLifecycleOwner = "linux-subreaper";
+        observeProcessOwnership(proc, executionId, ownershipLease);
+      } else {
+        proc = nativeSpawnFn(command, args, optsForSpawn);
+      }
       if (builtInMacMcpPlan) {
         const callerLifeline = proc?.stdio?.[8];
         if (
@@ -4912,6 +4994,10 @@ class ProcessExecutionBroker extends EventEmitter {
 
       proc.on("exit", (code, signal) => {
         const endTime = Date.now();
+        if (proc.ownedProcessTreeEvidence) {
+          auditEntry.processLifecycleReceipt = proc.ownedProcessTreeEvidence;
+          auditEntry.sandboxTargetPid = proc.sandboxTargetPid;
+        }
         auditEntry.exitCode = code;
         auditEntry.signal = signal;
         auditEntry.endTime = endTime;
@@ -4929,6 +5015,10 @@ class ProcessExecutionBroker extends EventEmitter {
         this.emit("exit", auditEntry);
       });
       proc.on("error", (err) => {
+        if (proc.ownedProcessTreeEvidence) {
+          auditEntry.processLifecycleReceipt = proc.ownedProcessTreeEvidence;
+          auditEntry.sandboxTargetPid = proc.sandboxTargetPid;
+        }
         auditEntry.error = err.message;
         auditEntry.endTime = Date.now();
         auditEntry.durationMs = auditEntry.endTime - startTime;
@@ -4957,6 +5047,7 @@ class ProcessExecutionBroker extends EventEmitter {
   }
 
   spawnSync(command, args, options = {}) {
+    assertProcessOwnershipAvailable();
     options = this._withAmbientProcessContext(command, options);
     const executionId = crypto.randomUUID();
     const startTime = Date.now();
@@ -5203,6 +5294,7 @@ class ProcessExecutionBroker extends EventEmitter {
    * together with the descriptor-pinned generic bwrap plan.
    */
   spawnPty(ptyModule, command, args = [], options = {}) {
+    assertProcessOwnershipAvailable();
     if (!ptyModule || typeof ptyModule.spawn !== "function") {
       throw new TypeError("pty_module_spawn_unavailable");
     }

package/src/lib/process-execution-broker/linux-subreaper-artifact.js

@@ -0,0 +1,120 @@
+import crypto from "node:crypto";
+
+export const LINUX_SUBREAPER_SOURCE_DIGEST =
+  "sha256:e920e24b4a79121484f2e8e97886755f88eaa1af93b55326dfa68c7a7f571424";
+export const LINUX_SUBREAPER_ARCHITECTURES = Object.freeze(["x64", "arm64"]);
+export const MAX_SUBREAPER_IMAGE_BYTES = 4 * 1024 * 1024;
+export const MAX_SUBREAPER_MANIFEST_BYTES = 4096;
+
+export function subreaperDigest(bytes) {
+  return "sha256:" + crypto.createHash("sha256").update(bytes).digest("hex");
+}
+
+function invalid(reason) {
+  const error = new Error(
+    `Linux process supervision helper unavailable: ${reason}`,
+  );
+  error.code = "EXTERNAL_AGENT_HELPER_UNAVAILABLE";
+  return error;
+}
+
+/** Bounded ELF64 inspection; release images have no dynamic loader dependency. */
+export function validateLinuxSubreaperElf(bytes, { arch, staticOnly = false }) {
+  const machine = arch === "x64" ? 62 : arch === "arm64" ? 183 : null;
+  if (
+    !machine ||
+    !Buffer.isBuffer(bytes) ||
+    bytes.length < 64 ||
+    bytes.length > MAX_SUBREAPER_IMAGE_BYTES ||
+    !bytes.subarray(0, 4).equals(Buffer.from([0x7f, 0x45, 0x4c, 0x46])) ||
+    bytes[4] !== 2 ||
+    bytes[5] !== 1 ||
+    bytes[6] !== 1 ||
+    bytes.readUInt16LE(18) !== machine ||
+    ![2, 3].includes(bytes.readUInt16LE(16)) ||
+    bytes.readUInt32LE(20) !== 1 ||
+    bytes.readUInt16LE(52) !== 64 ||
+    bytes.readUInt16LE(54) !== 56
+  )
+    throw invalid("unexpected-helper-image");
+  const offset = bytes.readBigUInt64LE(32);
+  const count = bytes.readUInt16LE(56);
+  if (
+    offset < 64n ||
+    count < 1 ||
+    count > 128 ||
+    offset + BigInt(count * 56) > BigInt(bytes.length)
+  )
+    throw invalid("invalid-helper-program-headers");
+  const entry = bytes.readBigUInt64LE(24);
+  let executableEntry = false;
+  for (let index = 0; index < count; index++) {
+    const at = Number(offset) + index * 56;
+    const type = bytes.readUInt32LE(at);
+    if (staticOnly && [2, 3].includes(type))
+      throw invalid("helper-is-not-static");
+    if (type !== 1) continue;
+    const fileOffset = bytes.readBigUInt64LE(at + 8);
+    const address = bytes.readBigUInt64LE(at + 16);
+    const fileSize = bytes.readBigUInt64LE(at + 32);
+    const memorySize = bytes.readBigUInt64LE(at + 40);
+    if (fileSize > memorySize || fileOffset + fileSize > BigInt(bytes.length))
+      throw invalid("invalid-helper-load-segment");
+    if (
+      bytes.readUInt32LE(at + 4) & 1 &&
+      entry >= address &&
+      entry < address + fileSize
+    )
+      executableEntry = true;
+  }
+  if (!executableEntry || (staticOnly && bytes.readUInt16LE(16) !== 2))
+    throw invalid("invalid-helper-entry");
+}
+
+export function validateLinuxSubreaperArtifact(
+  manifestBytes,
+  imageBytes,
+  { arch, commit } = {},
+) {
+  if (
+    !Buffer.isBuffer(manifestBytes) ||
+    manifestBytes.length > MAX_SUBREAPER_MANIFEST_BYTES
+  )
+    throw invalid("invalid-packaged-manifest");
+  let manifest;
+  try {
+    manifest = JSON.parse(manifestBytes.toString("utf8"));
+  } catch {
+    throw invalid("invalid-packaged-manifest");
+  }
+  const keys = [
+    "schema",
+    "platform",
+    "arch",
+    "sourceDigest",
+    "imageDigest",
+    "bytes",
+    "linkage",
+    "commit",
+  ];
+  if (
+    !manifest ||
+    typeof manifest !== "object" ||
+    Array.isArray(manifest) ||
+    Object.keys(manifest).length !== keys.length ||
+    Object.keys(manifest).some((key) => !keys.includes(key)) ||
+    manifest.schema !== "chainlesschain.linux-subreaper-artifact/v1" ||
+    manifest.platform !== "linux" ||
+    !LINUX_SUBREAPER_ARCHITECTURES.includes(arch) ||
+    manifest.arch !== arch ||
+    manifest.sourceDigest !== LINUX_SUBREAPER_SOURCE_DIGEST ||
+    manifest.linkage !== "static" ||
+    !/^[a-f0-9]{40}$/.test(manifest.commit) ||
+    (commit !== undefined && manifest.commit !== commit) ||
+    manifest.bytes !== imageBytes.length ||
+    manifest.imageDigest !== subreaperDigest(imageBytes)
+  )
+    throw invalid("packaged-identity-mismatch");
+  validateLinuxSubreaperElf(imageBytes, { arch, staticOnly: true });
+  return Object.freeze({ ...manifest });
+}