chainlesschain 0.166.46 → 0.166.48

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

@@ -6,6 +6,7 @@ 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" }),
 ]);
 
 function adapterError(code, message, details = {}) {
@@ -66,18 +67,40 @@ function projectNotification(notification) {
     };
   }
   if (method === "turn/completed" || method === "turn/failed") {
-    const failed = method === "turn/failed";
+    const turn = params.turn || {};
+    const reportedStatus =
+      method === "turn/failed" ? "failed" : String(turn.status || "");
+    const terminalStatus = ["completed", "failed", "interrupted"].includes(
+      reportedStatus,
+    )
+      ? reportedStatus
+      : "failed";
+    const protocolError =
+      terminalStatus === "failed" && reportedStatus !== "failed"
+        ? {
+            code: "CC_CODEX_APP_SERVER_INVALID_TERMINAL_STATUS",
+            message:
+              "Codex App Server emitted turn/completed without a supported terminal status",
+          }
+        : null;
+    const terminalError =
+      terminalStatus === "failed"
+        ? turn.error ||
+          params.error ||
+          protocolError ||
+          "Codex App Server turn failed"
+        : turn.error || params.error || null;
     return {
       method: "turn/completed",
       params: {
         turn: {
-          ...params.turn,
-          status: failed ? "failed" : "completed",
+          ...turn,
+          status: terminalStatus,
         },
       },
-      terminal: failed ? "failed" : "completed",
-      error: failed ? params.error || "Codex App Server turn failed" : null,
-      usage: params.usage || null,
+      terminal: terminalStatus,
+      error: terminalError,
+      usage: params.usage || turn.usage || null,
     };
   }
   return { unknownMethod: String(method || "<missing>") };
@@ -138,6 +161,10 @@ export class CodexAppServerAdapter extends EventEmitter {
     const notifications = [];
     const unknownMethods = new Set();
     let output = "";
+    let activeThreadId = threadId;
+    let submissionStarted = false;
+    let admissionObserved = false;
+    let observedTerminal = null;
     let terminalResolve;
     let terminalReject;
     const terminal = new Promise((resolve, reject) => {
@@ -162,16 +189,38 @@ export class CodexAppServerAdapter extends EventEmitter {
         notifications.push(projected);
         this.emit("notification", projected);
       }
+      if (
+        submissionStarted &&
+        (projected.method === "turn/started" ||
+          projected.method?.startsWith("item/") ||
+          Boolean(projected.terminal))
+      ) {
+        admissionObserved = true;
+      }
       if (projected.output) output = projected.output;
-      if (projected.terminal) terminalResolve(projected);
+      if (projected.terminal) {
+        observedTerminal = projected;
+        terminalResolve(projected);
+      }
     };
     this.client.on?.("notification", onNotification);
-    let admitted = false;
+    const buildResult = (terminalEvent) =>
+      Object.freeze({
+        protocol: CODEX_APP_SERVER_PROTOCOL,
+        threadId: activeThreadId,
+        terminal: terminalEvent.terminal,
+        output,
+        error: terminalEvent.error || null,
+        usage: terminalEvent.usage || null,
+        notifications: Object.freeze(notifications),
+        unknownMethods: Object.freeze([...unknownMethods].sort()),
+        fallback: false,
+        authoritative: false,
+      });
     try {
       if (!this.client.running && typeof this.client.start === "function") {
         await this.client.start();
       }
-      let activeThreadId = threadId;
       if (!activeThreadId) {
         const started = await this.client.request("thread/start", {
           ephemeral: false,
@@ -185,31 +234,37 @@ export class CodexAppServerAdapter extends EventEmitter {
           "Codex App Server did not return a thread identity",
         );
       }
+      // Once turn/start begins, a rejected client promise cannot prove that
+      // 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 || "") }],
       });
-      admitted = true;
-      const terminalEvent =
-        started?.turn?.status === "completed"
-          ? { terminal: "completed", usage: started.turn.usage || null }
-          : await terminal;
-      return Object.freeze({
-        protocol: CODEX_APP_SERVER_PROTOCOL,
-        threadId: activeThreadId,
-        terminal: terminalEvent.terminal,
-        output,
-        error: terminalEvent.error || null,
-        usage: terminalEvent.usage || null,
-        notifications: Object.freeze(notifications),
-        unknownMethods: Object.freeze([...unknownMethods].sort()),
-        fallback: false,
-        authoritative: false,
-      });
+      admissionObserved = true;
+      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 },
+          })
+        : await terminal;
+      return buildResult(terminalEvent);
     } catch (error) {
-      if (!admitted) {
+      if (!submissionStarted) {
         return this._fallback(prompt, options, error?.code || "startup_failed");
       }
+      if (observedTerminal) return buildResult(observedTerminal);
+      if (!admissionObserved) {
+        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 },
+        );
+      }
       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",

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

@@ -170,11 +170,14 @@ export class DurableJsonMemoryPort {
     filePath = join(getHomeDir(), "context-memory", "kernel-v1.json"),
     maxStoreBytes = DEFAULT_MAX_STORE_BYTES,
     maxEvents = DEFAULT_MAX_EVENTS,
+    lockObserver = null,
   } = {}) {
     this.name = "cli-context-memory-authority";
     this.filePath = filePath;
     this.maxStoreBytes = maxStoreBytes;
     this.maxEvents = maxEvents;
+    this.lockObserver =
+      typeof lockObserver === "function" ? lockObserver : null;
   }
 
   _readUnlocked() {
@@ -182,7 +185,10 @@ export class DurableJsonMemoryPort {
     if (!existsSync(this.filePath)) return initializeState();
     const bytes = readFileSync(this.filePath);
     if (bytes.length > this.maxStoreBytes) {
-      throw corruptStore(this.filePath, "store exceeds its configured byte limit");
+      throw corruptStore(
+        this.filePath,
+        "store exceeds its configured byte limit",
+      );
     }
     try {
       return normalizeState(JSON.parse(bytes.toString("utf8")), this.filePath);
@@ -194,13 +200,30 @@ export class DurableJsonMemoryPort {
 
   _locked(operation) {
     mkdirSync(dirname(this.filePath), { recursive: true, mode: 0o700 });
-    return withFileLock(this.filePath, operation, {
-      failIfUnavailable: true,
-      timeoutMs: 30_000,
-      retryMs: 2,
-      maxRetryMs: 32,
-      retryJitterMs: 8,
-    });
+    return withFileLock(
+      this.filePath,
+      (context) => {
+        if (this.lockObserver) {
+          try {
+            this.lockObserver({
+              locked: context.locked,
+              waitMs: context.waitMs,
+              attempts: context.attempts,
+            });
+          } catch {
+            // Diagnostics must not alter the authority operation.
+          }
+        }
+        return operation(context);
+      },
+      {
+        failIfUnavailable: true,
+        timeoutMs: 30_000,
+        retryMs: 2,
+        maxRetryMs: 32,
+        retryJitterMs: 8,
+      },
+    );
   }
 
   async read(memoryId) {

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

@@ -4,7 +4,7 @@ import {
   isProtected,
   normalizeContextItem,
 } from "@chainlesschain/context-memory-kernel";
-import { getContextWindow } from "../model-context-window.js";
+import { resolveModelCapabilityProfile } from "../model-capabilities.js";
 import { createCliContextMemoryRuntime } from "./runtime.js";
 import {
   contextItemsToMessages,
@@ -12,6 +12,9 @@ import {
   messagesToContextItems,
 } from "./message-adapter.js";
 
+export const SEMANTIC_CANDIDATE_REQUEST_SCHEMA =
+  "chainlesschain.context-memory-semantic-candidate-request/v1";
+
 function defaultAdmissions(sessionId, options) {
   const candidates = [
     { scope: "session", scopeId: sessionId },
@@ -19,9 +22,10 @@ function defaultAdmissions(sessionId, options) {
     { scope: "user", scopeId: options.userId || "local-user" },
   ];
   const configured = options.contextMemoryScopeAdmissions;
-  const admissions = Array.isArray(configured) && configured.length > 0
-    ? configured
-    : candidates;
+  const admissions =
+    Array.isArray(configured) && configured.length > 0
+      ? configured
+      : candidates;
   const seen = new Set();
   return admissions.filter((entry) => {
     const key = `${entry.scope}\0${entry.scopeId || ""}`;
@@ -31,6 +35,57 @@ function defaultAdmissions(sessionId, options) {
   });
 }
 
+function semanticCandidateProvider(options) {
+  const provider = options.contextMemorySemanticCandidateProvider;
+  if (provider == null) return null;
+  if (typeof provider !== "function") {
+    throw new TypeError(
+      "contextMemorySemanticCandidateProvider must be a function",
+    );
+  }
+  return provider;
+}
+
+/**
+ * Ask a host-owned semantic index for opaque record identifiers. The host sees
+ * the query and admission boundary but never receives canonical record content;
+ * the kernel later validates every returned revision/digest and applies its
+ * lifecycle, scope, expiry, and sink filters before ranking.
+ */
+async function resolveSemanticCandidates({
+  provider,
+  sessionId,
+  query,
+  sink,
+  scopeAdmissions,
+  limit,
+}) {
+  if (!provider) return undefined;
+  const candidates = await provider(
+    Object.freeze({
+      schema: SEMANTIC_CANDIDATE_REQUEST_SCHEMA,
+      sessionId,
+      query,
+      sink,
+      scopeAdmissions: Object.freeze(
+        scopeAdmissions.map((entry) => Object.freeze({ ...entry })),
+      ),
+      limit,
+      maxCandidates: 1000,
+    }),
+  );
+  if (!Array.isArray(candidates)) {
+    throw new TypeError(
+      "contextMemorySemanticCandidateProvider must resolve to an array",
+    );
+  }
+  return candidates.map((candidate) =>
+    candidate && typeof candidate === "object" && !Array.isArray(candidate)
+      ? Object.freeze({ ...candidate })
+      : candidate,
+  );
+}
+
 function toolDefinitionsToContextItems(definitionsInput, { sessionId, sink }) {
   const definitions = Array.isArray(definitionsInput) ? definitionsInput : [];
   return definitions.map((definition, index) => {
@@ -83,6 +138,34 @@ export async function prepareCanonicalProviderContext(
 ) {
   const messages = Array.isArray(messagesInput) ? messagesInput : [];
   const sessionId = String(options.sessionId || "ephemeral-cli-session");
+  const planningRequested = options.contextMemorySkipPlanning !== true;
+  const provider = String(options.provider || "local");
+  const modelCapabilities = planningRequested
+    ? resolveModelCapabilityProfile({
+        provider,
+        model: options.model,
+        baseUrl: options.baseUrl,
+        contextMemoryModelWindowTokens: options.contextMemoryModelWindowTokens,
+        maxOutputTokens: options.maxOutputTokens,
+      })
+    : null;
+
+  // A request cap at or above the complete model window leaves no valid input
+  // allocation. Reject it before creating the memory runtime so an impossible
+  // request cannot write state or reach the provider.
+  if (
+    modelCapabilities !== null &&
+    modelCapabilities.requestMaxOutputTokens !== null &&
+    modelCapabilities.requestMaxOutputTokens >=
+      modelCapabilities.contextWindowTokens
+  ) {
+    const error = new RangeError(
+      "The configured output-token cap must be smaller than the model context window",
+    );
+    error.code = "CC_MODEL_OUTPUT_BUDGET_EXCEEDS_WINDOW";
+    throw error;
+  }
+
   const runtime = createCliContextMemoryRuntime({
     env: options.contextMemoryEnv || process.env,
     sessionId,
@@ -91,11 +174,17 @@ export async function prepareCanonicalProviderContext(
       ? { memoryFilePath: options.contextMemoryFilePath }
       : {}),
   });
-  if (!runtime.decision.canonical || options.contextMemorySkipPlanning === true) {
-    return { messages, plan: null, recall: null, decision: runtime.decision };
+  if (!runtime.decision.canonical || !planningRequested) {
+    return {
+      messages,
+      plan: null,
+      recall: null,
+      decision: runtime.decision,
+      modelCapabilities: null,
+    };
   }
 
-  const provider = String(options.provider || "local");
+  const candidateProvider = semanticCandidateProvider(options);
   const sink = String(options.contextMemorySink || `provider.${provider}`);
   const scopeAdmissions = defaultAdmissions(sessionId, options);
   const lastUser = [...messages]
@@ -105,15 +194,28 @@ export async function prepareCanonicalProviderContext(
     typeof lastUser?.content === "string" && lastUser.content.trim()
       ? lastUser.content.trim().slice(0, 32 * 1024)
       : "*";
+  const recallLimit = Math.max(
+    1,
+    Math.min(32, Number(options.contextMemoryRecallLimit) || 12),
+  );
+  const semanticCandidates = await resolveSemanticCandidates({
+    provider: candidateProvider,
+    sessionId,
+    query,
+    sink,
+    scopeAdmissions,
+    limit: recallLimit,
+  });
   const recall = await runtime.kernel.recallMemory({
     query,
     sink,
     scopeAdmissions,
-    limit: Math.max(1, Math.min(32, Number(options.contextMemoryRecallLimit) || 12)),
+    limit: recallLimit,
     tokenBudget: Math.max(
       1,
       Math.min(32_768, Number(options.contextMemoryRecallTokens) || 4096),
     ),
+    ...(semanticCandidates === undefined ? {} : { semanticCandidates }),
   });
   const messageItems = messagesToContextItems(messages, {
     sessionId,
@@ -130,15 +232,10 @@ export async function prepareCanonicalProviderContext(
     { sessionId, sink },
   );
   const items = [...messageItems, ...memoryItems, ...toolItems];
-  const modelWindowTokens = Math.max(
-    1024,
-    Number(options.contextMemoryModelWindowTokens) ||
-      getContextWindow(options.model, provider) ||
-      128 * 1024,
-  );
+  const modelWindowTokens = modelCapabilities.contextWindowTokens;
   const reservedOutputTokens = Math.min(
     modelWindowTokens - 1,
-    Math.max(256, Number(options.maxOutputTokens) || 4096),
+    Math.max(256, modelCapabilities.plannedOutputReserveTokens),
   );
   const safetyMarginTokens = Math.min(
     modelWindowTokens - reservedOutputTokens - 1,
@@ -185,10 +282,11 @@ export async function prepareCanonicalProviderContext(
     policyVersion: String(
       options.contextMemoryPolicyVersion || "cli-provider-v1",
     ),
-    modelProfile: `${provider}:${String(options.model || "default")}`.slice(
-      0,
-      256,
-    ),
+    modelProfile:
+      `${modelCapabilities.profileId}:${modelCapabilities.digest}`.slice(
+        0,
+        256,
+      ),
     sessionHead,
     memoryRevision: recall.memoryRevision,
   });
@@ -202,6 +300,7 @@ export async function prepareCanonicalProviderContext(
     plan,
     recall,
     decision: runtime.decision,
+    modelCapabilities,
   };
 }