chainlesschain 0.166.133 → 0.166.135

package/README.md

@@ -2,11 +2,19 @@
 
 Command-line interface for installing, configuring, and managing [ChainlessChain](https://www.chainlesschain.com), including the coding agent, governed tools, sessions, memory, and IDE integrations.
 
-## CLI 0.166.133
+## CLI 0.166.135
 
-This source tree targets package version **0.166.133**. It preserves required empty OpenAI Responses reasoning summaries, applies the self-evolution switch to all model-owning `cc ui` entry points, and supports explicitly configured OpenAI-compatible local/LAN platforms through `custom`, with optional credentials and unchanged endpoint/model aliases. It also exposes canonical allowed mutation paths in provider tool schemas while retaining execution-time scope and file-identity checks. Over **400 focused regression tests** passed for the model-platform and self-evolution fixes; these controlled tests do not establish live-platform acceptance or public availability.
+This release recovers genuine OpenAI Responses JSON disconnects before accepted output, bounds stalled requests, and settles completed streaming responses without waiting for socket EOF. It preserves empty tool allowlists across resume and rejects malformed saved permission, sandbox and budget settings. HTTP/provider failures, cancellation, usage persistence and incomplete tool-call replay protections remain authoritative.
 
-When this version is available from npm, install it with `npm i -g chainlesschain@0.166.133 --registry https://registry.npmjs.org`. The companion version pair is Open VSX **0.37.171** / JetBrains **0.4.188**; the CLI is published before its companion extensions. Kernel stays **0.1.11**. Consult the [current release guide](https://docs.chainlesschain.com/chainlesschain/agent-platform-release.html) for verified channel availability. Source preparation alone does not establish publication or release-gate success.
+Install with `npm i -g chainlesschain@0.166.135 --registry https://registry.npmjs.org`, restart the chat host, then run `cc --version` and `cc doctor`. Paired IDE versions are Open VSX **0.37.172** and JetBrains **0.4.189**, recommending CLI **0.166.135**; Kernel stays **0.1.11**. Check the [release guide](https://docs.chainlesschain.com/chainlesschain/agent-platform-release.html) for channel publication status. Microsoft Marketplace and PC/mobile releases are outside this release scope.
+
+The preceding OpenAI native cohort accepted **39/45** tasks. Runtime regression tests and this release do not change that historical result or establish formal paid/native production admission.
+
+## CLI 0.166.133 — verified preceding release
+
+CLI **0.166.133** is published on npm. It preserves required empty OpenAI Responses reasoning summaries, applies the self-evolution switch to all model-owning `cc ui` entry points, and supports explicitly configured OpenAI-compatible local/LAN platforms through `custom`, with optional credentials and unchanged endpoint/model aliases. It also exposes canonical allowed mutation paths in provider tool schemas while retaining execution-time scope and file-identity checks. Controlled regressions and release gates do not establish live-platform task acceptance.
+
+Install with `npm i -g chainlesschain@0.166.133 --registry https://registry.npmjs.org`, restart the chat host, then run `cc --version` and `cc doctor`. Companion Open VSX **0.37.171** / JetBrains **0.4.188** are public and recommend this CLI; their original payloads match the official artifacts. Kernel stays **0.1.11**. Exact source `2eb0c5b1e048509362f9d980f94acee55c2ffa9f` passed Linux, Windows and macOS CLI CI / CLI Strict Sandbox. [OIDC publication](https://github.com/chainlesschain/chainlesschain/actions/runs/41073612529) and [independent readback](https://github.com/chainlesschain/chainlesschain/actions/runs/41075409835) verified immutable package bytes and signed provenance. Consult the [current release guide](https://docs.chainlesschain.com/chainlesschain/agent-platform-release.html) for IDE channel availability. Microsoft Marketplace and PC/mobile releases are outside this release scope.
 
 ## CLI 0.166.132 — verified public baseline before this source revision
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chainlesschain",
-  "version": "0.166.133",
+  "version": "0.166.135",
   "description": "CLI for ChainlessChain - install, configure, and manage your personal AI management system",
   "type": "module",
   "bin": {

package/src/assets/linux-subreaper/linux-arm64/manifest.json

@@ -6,5 +6,5 @@
   "imageDigest": "sha256:6395a47a5bd9b038303e94a5e93754258c8480dab64635460f973eb93dc6f4d8",
   "bytes": 778808,
   "linkage": "static",
-  "commit": "2eb0c5b1e048509362f9d980f94acee55c2ffa9f"
+  "commit": "82aa6d703a8695721a7ccf0793a435853bc2bbf2"
 }

package/src/assets/linux-subreaper/linux-x64/manifest.json

@@ -6,5 +6,5 @@
   "imageDigest": "sha256:f162e55ad3f3f72f8a52e9d7f12b5b8db44506c2ca66a14d7d62d5cd4f12498e",
   "bytes": 934160,
   "linkage": "static",
-  "commit": "2eb0c5b1e048509362f9d980f94acee55c2ffa9f"
+  "commit": "82aa6d703a8695721a7ccf0793a435853bc2bbf2"
 }

package/src/data/changelog.json

@@ -1,6 +1,19 @@
 {
   "source": "CHANGELOG.md",
   "releases": [
+    {
+      "productVersion": null,
+      "cliVersion": "0.166.135",
+      "cliVersions": ["0.166.135"],
+      "date": "2026-10-31",
+      "title": "",
+      "sections": [
+        {
+          "heading": "Fixed - cc CLI 0.166.135: Responses disconnect recovery and launch policy preservation (candidate, 2026-10-31)",
+          "body": "- Recover genuine pre-output OpenAI Responses JSON disconnects with the existing bounded retry policy, distinct physical request IDs and synchronous usage settlement. Bound stalled headers and JSON reads, preserve HTTP/provider verdicts and caller cancellation, and keep workflow effects and incomplete tool streams non-replayable.\n- Settle completed Responses events without waiting for socket EOF. A hung reader cancellation no longer blocks timeout settlement; already queued transport aborts and user cancellation remain authoritative.\n- Select newly generated context handoffs before ordinary conversation so a full conversation partition cannot evict its summary. Retain the same input budget, data-only trust and oversized-summary rejection.\n- Preserve an explicit empty tool allowlist through saved launch argv and the CLI parser. Reject malformed persisted permission modes, sandbox modes and budgets instead of silently restoring weaker defaults.\n- Strengthen generic regression guidance for delegated lifecycle ownership, race controls, persisted history projections and a final response within the iteration budget. Add same-handle metadata-race and approval-cancellation controls without changing historical model candidates.\n- Give independent IDE cleanup a separate bounded deadline after the model task ends. The previous `verify-26` trace actually contains `error_max_turns` at 20/20; cleanup had obscured that result with an expired-deadline error. Historical OpenAI acceptance remains 39/45 and is not reclassified by these fixes.\n- Prepare companion Open VSX 0.37.172 and JetBrains 0.4.189 for CLI 0.166.135. Required child npm packages retain their published versions; publication must follow the exact-source multi-platform gates and upstream readback."
+        }
+      ]
+    },
     {
       "productVersion": null,
       "cliVersion": "0.166.133",

package/src/lib/background-launch-profile.js

@@ -666,6 +666,41 @@ export function normalizeBackgroundLaunchProfile(input) {
       `Unsupported background launch profile version: ${input?.version ?? "missing"}`,
     );
   }
+  const rejectField = (field) => {
+    const error = new Error(
+      `Invalid background launch profile field: ${field}`,
+    );
+    error.code = "BACKGROUND_LAUNCH_PROFILE_INVALID";
+    throw error;
+  };
+  // A persisted policy must not silently fall back to a weaker default.
+  if (
+    input.permission?.mode != null &&
+    !PERMISSION_MODES.has(input.permission.mode)
+  )
+    rejectField("permission.mode");
+  if (input.sandbox?.mode != null && !SANDBOX_MODES.has(input.sandbox.mode))
+    rejectField("sandbox.mode");
+  for (const field of [
+    "maxTurns",
+    "maxCostUsd",
+    "thinkingTokens",
+    "maxRewakes",
+    "maxOuterTurns",
+    "goalMaxTokens",
+    "goalMaxCostUsd",
+    "goalMaxTimeMs",
+  ]) {
+    const value = input.budget?.[field];
+    if (value == null || value === "") continue;
+    const number = Number(value);
+    if (
+      !Number.isFinite(number) ||
+      number <= 0 ||
+      (!field.toLowerCase().includes("cost") && !Number.isSafeInteger(number))
+    )
+      rejectField(`budget.${field}`);
+  }
   const cwd = canonicalPath(input.workspace?.cwd || process.cwd());
   const safeBase = sanitizeBackgroundBaseUrl(input.llm?.baseUrl);
   const permissionMode = PERMISSION_MODES.has(input.permission?.mode)
@@ -966,7 +1001,8 @@ export function buildArgvFromBackgroundLaunchProfile(profile) {
     pushValue(argv, "--fallback-model", model);
   }
   if (p.tools.allowed !== null) {
-    pushValue(argv, "--allowed-tools", p.tools.allowed.join(","));
+    // Empty means no tools; omitting this option would allow every tool.
+    argv.push("--allowed-tools", p.tools.allowed.join(","));
   }
   pushValue(argv, "--disallowed-tools", p.tools.disallowed.join(","));
   pushValue(argv, "--permission-mode", p.permission.mode);

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

@@ -1,14 +1,15 @@
 /** Shared correctness guidance for normal and file-only coding sessions. */
 export const CODING_TASK_QUALITY_GUIDANCE = `Coding task quality:
-- Read the actual implementation and its exported API before writing a caller or test. Check parameter order, return shapes, asynchronous lifecycle and fixture requirements against the source; an example in another directory can have different relative imports.
-- 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.
-- Finish requested file changes before the final response. Reserve output and remaining requests for writing, read-back and focused validation. For large files, aim for a few thousand characters of new content per call: write a small complete section, then extend it with edit_file using a unique existing anchor and a replacement containing that anchor plus the next complete section. A list of available tool names is not a limit on the number of tool calls; use further calls within the actual request budget to finish and inspect the file. Keep each tool call complete and wait for its result before extending the file again; do not repeatedly rewrite the growing file. State what was delivered, what was checked and what remains unverified, without repeating that account in multiple drafts.`;
+- Read the actual implementation and its exported API before writing a caller or test. Verify parameter order, return shapes, fixture requirements and the delegated owner of each lifecycle transition.
+- Keep progress explanations to one or two sentences. Resolve uncertainty with targeted reads, reuse unchanged source already inspected, and put code directly in write/edit arguments.
+- Resolve each relative import from the destination file's directory. Read back completed files and fix newDiagnostics. A successful write proves persistence, not test execution or acceptance.
+- Map every acceptance requirement to a fixture, real production call path and observable assertion. Positive and negative controls must reach the same boundary with unrelated prerequisites valid. Avoid mocks that bypass it; identify which assertion would fail without that boundary.
+- Derive case allocation from the user's requirements. A test-count cap does not waive coverage: merge redundant cases to cover gaps within the cap, authorized scope and remaining budget. Report unresolved gaps as incomplete.
+- For races, control the intended transition and complete the current worker/request when testing cancellation or replacement. An earlier unrelated rejection does not prove the target guard. Derive expectations independently from the contract or authoritative state, not by calling the function under test.
+- Trace rejection before asserting its aftermath: it may precede registration or persistence. Inspect whether state stays unchanged, a failed record exists or an event is emitted. Compare independently recorded identities and provenance; equal text does not prove ownership.
+- Inspect persistence projections before comparing histories. Host notices, lineage and imports may accompany user/assistant messages; verify their provenance separately. Report defects that cannot be repaired within the permitted scope instead of inventing passing behavior.
+- Run focused checks with permitted execution tools. With file tools only, inspect imports, contracts and fixtures and say tests were not run. Read-back or static inspection is not a passing test.
+- Finish requested edits and read-back before the final reply; reserve the last available model request for a concise terminal account. For large files, write a small complete section, await its result, then extend it with a unique edit anchor rather than rewriting the growing file. Report delivery, actual checks and limitations once.`;
 
 export const HERMETIC_CODING_SYSTEM_PROMPT = `You are a hermetic coding assistant. The exposed file tools are the complete tool surface. Inspect and mutate only the exact paths authorized by the user request. Do not invoke hidden tools, commands, language servers or other execution paths.
 

package/src/lib/context-memory-kernel/message-adapter.js

@@ -549,7 +549,11 @@ export function createSummaryContextItem({
       Math.ceil((Buffer.byteLength(content, "utf8") - image.bytes) / 4) +
         image.tokens,
     ),
-    priority: Math.max(...parents.map((item) => item.priority)),
+    // Keep the new handoff ahead of ordinary conversation in the final plan.
+    // Otherwise newer messages can fill the partition and evict the summary
+    // of the already-dropped history. This is selection priority only: the
+    // summary stays unpinned, data-only and subject to the same token ceilings.
+    priority: Math.max(600_000, ...parents.map((item) => item.priority)),
     pinned: false,
     createdAt: new Date(now).toISOString(),
     ...contentFields,

package/src/runtime/agent-core.js

@@ -12671,34 +12671,69 @@ export async function chatWithTools(rawMessages, options) {
       );
     }
 
-    const response = await providerFetch(`${url}/responses`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${key}`,
-        ...(supportsOpenAIRequestIdentity && providerRequestId
-          ? { "X-Client-Request-Id": providerRequestId }
+    // A JSON-body disconnect has produced no accepted output or executable
+    // tools. Apply the same bounded transport retry and usage settlement used
+    // by streaming; HTTP/provider verdicts and governed workflow calls retain
+    // their existing no-replay rules.
+    return await _retryStreamingChat(
+      (attempt = 0) =>
+        _withResponsesRequestDeadline(
+          async (requestSignal) => {
+            const requestId = supportsOpenAIRequestIdentity
+              ? _physicalProviderRequestId(providerRequestId, attempt)
+              : null;
+            const response = await providerFetch(`${url}/responses`, {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${key}`,
+                ...(requestId ? { "X-Client-Request-Id": requestId } : {}),
+              },
+              signal: requestSignal,
+              body: JSON.stringify(responseBody),
+            });
+            if (!response.ok) {
+              throw await createProviderResponseError(provider, response);
+            }
+            const retryMetadata = captureStreamRetryMetadata(response);
+            try {
+              const data = await response.json();
+              const out = normalizeOpenAIResponsesResponse(data);
+              if (out.usage)
+                out.usage = preserveRequestedServiceTierEvidence(
+                  out.usage,
+                  options.serviceTier,
+                );
+              delete out.responseId;
+              const providerReceipt = supportsOpenAIRequestIdentity
+                ? _openAIProviderRequestReceipt(response, data, requestId)
+                : null;
+              if (providerReceipt) out.providerReceipt = providerReceipt;
+              return out;
+            } catch (error) {
+              attachStreamRetryMetadata(error, retryMetadata);
+              throw error;
+            }
+          },
+          signal,
+          options.streamStallTimeoutMs,
+        ),
+      {
+        signal,
+        retries: options.workflowEffectId ? 0 : undefined,
+        strictRetryObserver: options.strictUsageTelemetry === true,
+        ...(typeof options.onStreamRetry === "function"
+          ? {
+              onRetry: (attempt, error, telemetry) =>
+                options.onStreamRetry(attempt, error, {
+                  ...telemetry,
+                  provider,
+                  model: effectiveModel,
+                }),
+            }
           : {}),
       },
-      signal,
-      body: JSON.stringify(responseBody),
-    });
-    if (!response.ok) {
-      throw await createProviderResponseError(provider, response);
-    }
-    const data = await response.json();
-    const out = normalizeOpenAIResponsesResponse(data);
-    if (out.usage)
-      out.usage = preserveRequestedServiceTierEvidence(
-        out.usage,
-        options.serviceTier,
-      );
-    delete out.responseId;
-    const providerReceipt = supportsOpenAIRequestIdentity
-      ? _openAIProviderRequestReceipt(response, data, providerRequestId)
-      : null;
-    if (providerReceipt) out.providerReceipt = providerReceipt;
-    return out;
+    );
   }
 
   // Real token streaming (--include-partial-messages) for every OpenAI-compatible
@@ -13047,6 +13082,36 @@ const STREAM_STALL_MS = 20000;
 const STREAM_STALL_TIMEOUT_MS = 180000;
 const _STREAM_STALL = Symbol("stream-stall");
 
+/** Bound the whole JSON attempt, including headers and a stalled body read. */
+async function _withResponsesRequestDeadline(
+  operation,
+  signal,
+  configuredTimeout,
+) {
+  const timeoutMs = configuredTimeout ?? STREAM_STALL_TIMEOUT_MS;
+  if (timeoutMs === 0) return operation(signal);
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 0 || timeoutMs > 2_147_483_647)
+    throw new RangeError("Invalid Responses request timeout");
+  const controller = new AbortController();
+  const requestSignal = signal
+    ? AbortSignal.any([signal, controller.signal])
+    : controller.signal;
+  const timer = setTimeout(() => {
+    const error = new Error(
+      "OpenAI Responses request timed out before its complete response was received",
+    );
+    error.code = "ETIMEDOUT";
+    controller.abort(error);
+  }, timeoutMs);
+  timer.unref?.();
+  try {
+    throwIfAborted(requestSignal);
+    return await raceWithAbort(operation(requestSignal), requestSignal);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 /**
  * Run a streaming chat attempt with bounded auto-retry on transient API
  * connection drops (Claude-Code 2.1.181: "auto-retry for API connection drops
@@ -13176,7 +13241,9 @@ export async function* _iterateStreamWithStall(reader, opts = {}) {
       // socket) and throw a retryable error the dispatch seam re-issues.
       if (timeoutMs && elapsed >= timeoutMs) {
         try {
-          await reader.cancel();
+          // Cancellation itself can hang on a broken transport. Observe its
+          // rejection, but never let it postpone the authoritative timeout.
+          void Promise.resolve(reader.cancel()).catch(() => {});
         } catch {
           /* best-effort release — the throw below is what matters */
         }
@@ -13474,7 +13541,7 @@ async function _chatOpenAIResponsesStreaming(
   const decoder = new TextDecoder();
   let buf = "";
   try {
-    for await (const value of _iterateStreamWithStall(reader, {
+    responses: for await (const value of _iterateStreamWithStall(reader, {
       onStall,
       stallMs,
       stallTimeoutMs,
@@ -13485,6 +13552,22 @@ async function _chatOpenAIResponsesStreaming(
       for (const line of lines) {
         reduceOpenAIResponsesStreamLine(state, line, ui.onToken, ui.onThinking);
         await ui.settle();
+        if (state.terminalError) throw state.terminalError;
+        if (state.normalized) {
+          // response.completed/incomplete is authoritative. Some gateways
+          // leave the HTTP stream alive after it; socket EOF is not required.
+          // Observe an already-queued transport error (especially cancellation)
+          // without waiting for a pending trailing read to finish.
+          await Promise.race([reader.read(), Promise.resolve()]);
+          throwIfAborted(signal);
+          try {
+            void Promise.resolve(reader.cancel()).catch(() => {});
+          } catch {
+            // The terminal response is already complete; cleanup is best effort.
+          }
+          buf = "";
+          break responses;
+        }
       }
     }
     if (buf.trim()) {
@@ -13526,6 +13609,12 @@ async function _chatOpenAIResponsesStreaming(
     );
     if (providerReceipt) out.providerReceipt = providerReceipt;
     return out;
+  } finally {
+    try {
+      reader.releaseLock?.();
+    } catch {
+      // A cancelled or still-settling reader can reject lock release.
+    }
   }
   const out = finalizeOpenAIResponsesStream(state);
   if (out.usage)

package/src/runtime/headless-runner.js

@@ -467,15 +467,15 @@ export function resolveEnabledTools({ allowedTools, readOnly } = {}) {
   return names;
 }
 
-/** Normalize a comma/space separated CLI list into a string[] (or null). */
+/** An absent CLI list is unrestricted; an explicit empty list permits none. */
 export function parseToolList(value) {
-  if (!value) return null;
+  if (value === null || value === undefined) return null;
   if (Array.isArray(value)) return value.flatMap((v) => parseToolList(v) || []);
   const out = String(value)
     .split(/[,\s]+/)
     .map((s) => s.trim())
     .filter(Boolean);
-  return out.length > 0 ? out : null;
+  return out;
 }
 
 /**