chainlesschain 0.166.77 → 0.166.78

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

@@ -39,21 +39,62 @@ function projectNotification(notification) {
   if (method === "turn/started") {
     return { method: "turn/started", params: { turn: params.turn } };
   }
+  const deltaKinds = {
+    "item/agentMessage/delta": "assistant_message",
+    "item/commandExecution/outputDelta": "tool",
+    "item/fileChange/outputDelta": "tool",
+    "item/reasoning/textDelta": "reasoning",
+    "item/reasoning/summaryTextDelta": "reasoning",
+  };
+  if (Object.hasOwn(deltaKinds, method)) {
+    return {
+      method: "item/delta",
+      params: {
+        item: {
+          id: params.itemId,
+          kind: deltaKinds[method],
+          status: "streaming",
+          delta: params.delta || "",
+        },
+      },
+      ...(method === "item/agentMessage/delta"
+        ? {
+            outputDelta: String(params.delta || ""),
+            outputItemId: params.itemId,
+          }
+        : {}),
+    };
+  }
+  if (method === "thread/tokenUsage/updated") {
+    return {
+      method: "thread/usage",
+      params: { tokenUsage: params.tokenUsage },
+      usage: params.tokenUsage?.last || null,
+    };
+  }
   if (["item/started", "item/updated", "item/completed"].includes(method)) {
     const item = params.item || {};
-    const status = method === "item/completed" ? "completed" : "streaming";
+    const tool = item.type === "commandExecution" || item.type === "fileChange";
+    let status = method === "item/completed" ? "completed" : "streaming";
+    // item/completed means lifecycle closure, not successful execution. A
+    // declined approval still closes the tool item before interrupting the
+    // turn. Preserve that outcome and never infer success for unknown states.
+    if (method === "item/completed" && tool) {
+      status = ["completed", "failed", "declined"].includes(item.status)
+        ? item.status
+        : "unknown";
+    }
     return {
       method: method === "item/updated" ? "item/delta" : method,
       params: {
         item: {
           id: item.id,
           kind:
-            item.type === "agent_message"
+            item.type === "agentMessage"
               ? "assistant_message"
               : item.type === "reasoning"
                 ? "reasoning"
-                : item.type === "command_execution" ||
-                    item.type === "file_change"
+                : tool
                   ? "tool"
                   : "artifact",
           status,
@@ -61,9 +102,10 @@ function projectNotification(notification) {
         },
       },
       output:
-        method === "item/completed" && item.type === "agent_message"
+        method === "item/completed" && item.type === "agentMessage"
           ? String(item.text || "")
-          : "",
+          : undefined,
+      outputItemId: item.id,
     };
   }
   if (method === "turn/completed" || method === "turn/failed") {
@@ -160,44 +202,97 @@ export class CodexAppServerAdapter extends EventEmitter {
     }
     const notifications = [];
     const unknownMethods = new Set();
-    let output = "";
+    const outputItems = new Map();
+    let usage = null;
     let activeThreadId = threadId;
+    let activeTurnId = null;
     let submissionStarted = false;
     let admissionObserved = false;
     let observedTerminal = null;
     let terminalResolve;
-    let terminalReject;
-    const terminal = new Promise((resolve, reject) => {
+    const terminal = new Promise((resolve) => {
       terminalResolve = resolve;
-      terminalReject = reject;
     });
+    let deadlineReject;
+    const deadline = new Promise((_, reject) => {
+      deadlineReject = reject;
+    });
+    // Attach immediately: startup/RPC may hang or reject before terminal await.
+    deadline.catch(() => {});
     const timer = setTimeout(
       () =>
-        terminalReject(
+        deadlineReject(
           adapterError(
             "CC_CODEX_APP_SERVER_TIMEOUT",
-            "Codex App Server turn timed out after admission",
+            "Codex App Server request timed out",
           ),
         ),
       this.timeoutMs,
     );
     timer.unref?.();
+    const withinDeadline = (pending) => Promise.race([pending, deadline]);
+    let buffered = [];
+    let retainedBytes = 0;
+    let eventFailure = null;
+    const retain = (notification) => {
+      retainedBytes += Buffer.byteLength(JSON.stringify(notification));
+      if (
+        retainedBytes > 4 * 1024 * 1024 ||
+        notifications.length + buffered.length >= 4096
+      ) {
+        eventFailure = adapterError(
+          "CC_CODEX_APP_SERVER_EVENT_LIMIT",
+          "Codex App Server event retention limit exceeded",
+        );
+        deadlineReject(eventFailure);
+        return false;
+      }
+      return true;
+    };
     const onNotification = (notification) => {
+      if (observedTerminal || eventFailure || !submissionStarted) return;
+      const params = notification?.params || {};
+      const eventThread =
+        params.threadId ||
+        (notification.method === "thread/started" ? params.thread?.id : null);
+      if (!eventThread || eventThread !== activeThreadId) return;
+      if (!activeTurnId) {
+        if (retain(notification)) buffered.push(notification);
+        return;
+      }
+      const eventTurn = params.turnId || params.turn?.id;
+      // Thread-wide events carry no turn. Only thread/started is safe to
+      // project here; usage and terminal events require the exact turn ID.
+      if (
+        notification.method !== "thread/started" &&
+        eventTurn !== activeTurnId
+      )
+        return;
+      if (!retain(notification)) return;
       const projected = projectNotification(notification);
-      if (projected.unknownMethod) unknownMethods.add(projected.unknownMethod);
-      else {
+      if (projected.unknownMethod) {
+        if (unknownMethods.size < 64)
+          unknownMethods.add(projected.unknownMethod);
+      } else {
+        projected.params = {
+          ...projected.params,
+          threadId: activeThreadId,
+          turnId: activeTurnId,
+        };
         notifications.push(projected);
         this.emit("notification", projected);
       }
-      if (
-        submissionStarted &&
-        (projected.method === "turn/started" ||
-          projected.method?.startsWith("item/") ||
-          Boolean(projected.terminal))
-      ) {
-        admissionObserved = true;
+      if (projected.outputItemId) {
+        if (projected.output !== undefined)
+          outputItems.set(projected.outputItemId, projected.output);
+        else if (projected.outputDelta)
+          outputItems.set(
+            projected.outputItemId,
+            (outputItems.get(projected.outputItemId) || "") +
+              projected.outputDelta,
+          );
       }
-      if (projected.output) output = projected.output;
+      if (projected.usage) usage = projected.usage;
       if (projected.terminal) {
         observedTerminal = projected;
         terminalResolve(projected);
@@ -208,10 +303,11 @@ export class CodexAppServerAdapter extends EventEmitter {
       Object.freeze({
         protocol: CODEX_APP_SERVER_PROTOCOL,
         threadId: activeThreadId,
+        turnId: activeTurnId,
         terminal: terminalEvent.terminal,
-        output,
+        output: [...outputItems.values()].join("\n"),
         error: terminalEvent.error || null,
-        usage: terminalEvent.usage || null,
+        usage: terminalEvent.usage || usage,
         notifications: Object.freeze(notifications),
         unknownMethods: Object.freeze([...unknownMethods].sort()),
         fallback: false,
@@ -219,13 +315,14 @@ export class CodexAppServerAdapter extends EventEmitter {
       });
     try {
       if (!this.client.running && typeof this.client.start === "function") {
-        await this.client.start();
+        await withinDeadline(this.client.start());
       }
       if (!activeThreadId) {
-        const started = await this.client.request("thread/start", {
-          ephemeral: false,
-          provider: "codex",
-        });
+        const started = await withinDeadline(
+          this.client.request("thread/start", {
+            ephemeral: false,
+          }),
+        );
         activeThreadId = started?.thread?.id;
       }
       if (!activeThreadId) {
@@ -238,20 +335,49 @@ export class CodexAppServerAdapter extends EventEmitter {
       // the server did not accept the input. Never launch a second execution
       // path from that ambiguous state.
       submissionStarted = true;
-      const started = await this.client.request("turn/start", {
-        threadId: activeThreadId,
-        input: [{ type: "text", text: String(prompt || "") }],
-      });
+      const started = await withinDeadline(
+        this.client.request("turn/start", {
+          threadId: activeThreadId,
+          input: [{ type: "text", text: String(prompt || "") }],
+        }),
+      );
+      activeTurnId = started?.turn?.id;
+      if (typeof activeTurnId !== "string" || !activeTurnId) {
+        throw adapterError(
+          "CC_CODEX_APP_SERVER_PROTOCOL_FAILED",
+          "Codex App Server did not return a turn identity",
+        );
+      }
       admissionObserved = true;
+      if (eventFailure) throw eventFailure;
+      const early = buffered;
+      buffered = [];
+      retainedBytes = 0;
+      for (const notification of early) onNotification(notification);
+      if (eventFailure) throw eventFailure;
+      // Some servers finish before writing the RPC response, including items
+      // in the response without separate item notifications.
+      if (!observedTerminal)
+        for (const item of started.turn.items || []) {
+          onNotification({
+            method: "item/completed",
+            params: { threadId: activeThreadId, turnId: activeTurnId, item },
+          });
+        }
+      if (eventFailure) throw eventFailure;
       const initialStatus = String(started?.turn?.status || "");
       const terminalEvent = ["completed", "failed", "interrupted"].includes(
         initialStatus,
       )
         ? projectNotification({
             method: "turn/completed",
-            params: { turn: started.turn, usage: started.turn.usage || null },
+            params: {
+              threadId: activeThreadId,
+              turn: started.turn,
+              usage: started.turn.usage || null,
+            },
           })
-        : await terminal;
+        : await withinDeadline(terminal);
       return buildResult(terminalEvent);
     } catch (error) {
       if (!submissionStarted) {

package/src/lib/cost-budget.js

@@ -18,6 +18,7 @@
  */
 
 import { estimateCost } from "./llm-pricing.js";
+import { projectUsagePricingContext } from "./usage-pricing-context.js";
 
 /** Parse a `--max-budget-usd` value into a positive number, or null when unset. */
 export function parseBudgetUsd(value) {
@@ -64,6 +65,7 @@ export class CostBudget {
     // or it undercounts real spend on a cached Anthropic run and stops too late.
     const cacheReadTokens = usage?.cache_read_input_tokens || 0;
     const cacheCreationTokens = usage?.cache_creation_input_tokens || 0;
+    const pricingContext = projectUsagePricingContext(usage || {});
     const est = estimateCost({
       provider,
       model,
@@ -71,6 +73,8 @@ export class CostBudget {
       outputTokens: usage?.output_tokens || 0,
       cacheReadTokens,
       cacheCreationTokens,
+      serviceTier: pricingContext.service_tier ?? "standard",
+      regionalProcessing: pricingContext.regional_processing === true,
       table: this.table,
     });
     const tokens =

package/src/lib/doctor-checkup.js

@@ -26,6 +26,7 @@ import {
   rmSync,
 } from "node:fs";
 import { join, basename } from "node:path";
+import { release as kernelRelease } from "node:os";
 import { getHomeDir, getConfigPath } from "./paths.js";
 import { inspectPrivatePaths, repairPrivatePaths } from "./secure-fs.js";
 import executionBroker from "./process-execution-broker/index.js";
@@ -68,6 +69,7 @@ export const _deps = {
   spawnSync: (...args) => executionBroker.spawnSync(...args),
   now: () => Date.now(),
   platform: () => process.platform,
+  kernelRelease,
 };
 
 function check(id, name, level, detail = "", fix = null) {
@@ -1242,12 +1244,39 @@ async function runtimeSection(opts, deps) {
 
 // ── execution context (P1-7) ───────────────────────────────────────────────
 // "任务在哪执行是 Session 一等属性": surface the DETECTED execution location and
-// the fail-closed permission posture it implies. Read-only advisory — it never
-// blocks. A local trusted machine is OK; a remote/unknown environment is a WARN
+// the fail-closed permission posture it implies. Read-only diagnosis; this does
+// not change execution authority. A remote/unknown environment is a WARN
 // because a session there fails closed to read-only unless powers are granted
 // explicitly (and any policy violation from the pure model is listed).
 async function executionSection(opts, deps) {
   const checks = [];
+  try {
+    // WSL1 lacks STATX_BTIME: Node substitutes mutable ctime for birthtime.
+    // Do not silently drop generation from workspace identity, reset consent,
+    // or claim that a different kernel establishes filesystem trust support.
+    if (
+      deps.platform() === "linux" &&
+      /^4\.4\..*-Microsoft$/iu.test(deps.kernelRelease())
+    ) {
+      checks.push(
+        check(
+          "workspace-trust-identity",
+          "Workspace trust filesystem identity",
+          CHECK_LEVELS.ERR,
+          "WSL1 reports mutable change time as creation time; workspace consent can be lost after directory edits or moves. Use the native Windows CLI for workspace trust operations. There is no safe automatic repair.",
+        ),
+      );
+    }
+  } catch {
+    checks.push(
+      check(
+        "workspace-trust-identity",
+        "Workspace trust filesystem identity",
+        CHECK_LEVELS.ERR,
+        "Kernel information is unavailable; the WSL1 workspace trust limitation could not be checked.",
+      ),
+    );
+  }
   try {
     const {
       detectAmbientLocation,

package/src/lib/durable-security-store.js

@@ -48,7 +48,12 @@ export function readSecurityStore(filePath, label) {
 
 export function writeSecurityStore(filePath, label, store) {
   const directory = path.dirname(filePath);
-  fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+  // A caller may already hold a Linux directory through /proc/self/fd/N.
+  // WSL1 refuses mkdir on that existing descriptor alias; keep all later
+  // writes and fsync bound to the held directory without reopening its path.
+  if (!fs.statSync(directory, { throwIfNoEntry: false })?.isDirectory()) {
+    fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+  }
   const temporaryPath = path.join(
     directory,
     `.${path.basename(filePath)}.${process.pid}.${crypto.randomUUID()}.tmp`,

package/src/lib/evolution/evolution-artifact-identity.js

@@ -0,0 +1,21 @@
+import os from "node:os";
+
+// WSL1's stat fallback reports ctime as birthtime. Creating an index or child
+// directory changes that value without replacing the object. It supplies no
+// creation-time identity; keep device/inode and the caller's no-link, physical
+// containment and descriptor checks. WSL2 and other platforms retain birthtime.
+export function artifactPhysicalIdentity(
+  stat,
+  { platform = process.platform, kernelRelease = os.release() } = {},
+) {
+  const birthtimeMs = Number(stat.birthtimeMs);
+  const wsl1CtimeFallback =
+    platform === "linux" &&
+    /^4\.4\..*-Microsoft$/iu.test(kernelRelease) &&
+    birthtimeMs === Number(stat.ctimeMs);
+  return Object.freeze({
+    birthtimeMs: wsl1CtimeFallback ? null : birthtimeMs,
+    dev: String(stat.dev),
+    ino: String(stat.ino),
+  });
+}

package/src/lib/evolution/evolution-artifact-ports.js

@@ -13,6 +13,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { types as utilTypes } from "node:util";
 import { ArtifactStore } from "../artifact-store.js";
+import { artifactPhysicalIdentity as physicalIdentity } from "./evolution-artifact-identity.js";
 import { withEvolutionFileIdentity } from "./evolution-file-identity.js";
 import {
   EVOLUTION_ARTIFACT_REF_SCHEMA,
@@ -1060,19 +1061,12 @@ function isContained(root, candidate) {
   );
 }
 
-function physicalIdentity(stat) {
-  return Object.freeze({
-    birthtimeMs: Number(stat.birthtimeMs),
-    dev: String(stat.dev),
-    ino: String(stat.ino),
-  });
-}
-
 function samePhysicalIdentity(stat, expected) {
+  const actual = physicalIdentity(stat);
   return (
-    String(stat.dev) === expected.dev &&
-    String(stat.ino) === expected.ino &&
-    Number(stat.birthtimeMs) === expected.birthtimeMs
+    actual.dev === expected.dev &&
+    actual.ino === expected.ino &&
+    actual.birthtimeMs === expected.birthtimeMs
   );
 }