chainlesschain 0.166.76 → 0.166.78

package/src/lib/agent-router.js

@@ -228,12 +228,14 @@ export class AgentRouter extends EventEmitter {
    */
   static autoDetect(options = {}) {
     const backends = [];
+    const claude = options.cliDetections?.claude || detectClaudeCode();
+    const codex = options.cliDetections?.codex || detectCodex();
 
-    if (detectClaudeCode().found) {
-      backends.push({ type: BACKEND_TYPE.CLAUDE, weight: 3 });
+    if (claude.found) {
+      backends.push({ type: BACKEND_TYPE.CLAUDE, weight: 3, installed: true });
     }
-    if (detectCodex().found) {
-      backends.push({ type: BACKEND_TYPE.CODEX, weight: 2 });
+    if (codex.found) {
+      backends.push({ type: BACKEND_TYPE.CODEX, weight: 2, installed: true });
     }
     if (process.env.GEMINI_API_KEY) {
       backends.push({ type: BACKEND_TYPE.GEMINI, weight: 2 });
@@ -263,7 +265,7 @@ export class AgentRouter extends EventEmitter {
     const { cwd = process.cwd() } = options;
     if (this._backends.length === 0) {
       throw new Error(
-        "No agent backends available. Install Claude Code: npm i -g @anthropic-ai/claude-code",
+        "No agent backends available. Use cc agent for tool execution; orchestrate API backends produce text only.",
       );
     }
     const evolutionIngress =
@@ -277,8 +279,7 @@ export class AgentRouter extends EventEmitter {
       error.code = "CC_AGENT_EVOLUTION_INGRESS_FAILED";
       throw error;
     }
-    const backends =
-      this._backends.filter((backend) => !backend.isCLI);
+    const backends = this._backends.filter((backend) => !backend.isCLI);
 
     if (backends.length === 0) {
       const error = new Error(
@@ -475,6 +476,7 @@ export class AgentRouter extends EventEmitter {
         return {
           type,
           isCLI: true,
+          installed: cfg.installed ?? null,
           weight: cfg.weight || 1,
           _pool: pool,
           timeout: cfg.timeout || 300_000,
@@ -530,8 +532,34 @@ export class AgentRouter extends EventEmitter {
       kind: b.isCLI ? "cli" : "api",
       provider: b.provider || b.type,
       weight: b.weight,
+      installed: b.isCLI ? (b.installed ?? null) : null,
+      configured: true,
+      governanceAdmitted: b.isCLI ? false : null,
+      requiresAuthenticatedRun: true,
+      dispatchable: !b.isCLI,
+      runnable: false,
+      executionMode: b.isCLI ? "blocked" : "text-only",
+      blockedReason: b.isCLI
+        ? AGENT_ROUTER_ERROR.EXTERNAL_MODEL_INGRESS_UNATTESTED
+        : "API_TEXT_ONLY_NO_TOOL_EXECUTION",
+      alternative: "cc agent",
     }));
   }
+
+  /** Configuration preflight only; dispatch still authenticates each Run. */
+  assertDispatchAvailable() {
+    if (this._backends.some((backend) => !backend.isCLI)) return;
+    const error = new Error(
+      this._backends.length
+        ? "External Claude/Codex CLIs are blocked: per-request model governance is unattested. Use cc agent for tool execution."
+        : "No agent backends available. Use cc agent for tool execution.",
+    );
+    error.code = this._backends.length
+      ? AGENT_ROUTER_ERROR.EXTERNAL_MODEL_INGRESS_UNATTESTED
+      : "AGENT_ROUTER_NO_BACKENDS";
+    error.backends = this.summary();
+    throw error;
+  }
 }
 
 // ===== V2 Surface: Agent Router governance overlay (CLI v0.132.0) =====

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

@@ -1463,6 +1463,20 @@ export class CcAppServer {
       contextRevision: Number.isSafeInteger(event.context_revision)
         ? event.context_revision
         : null,
+      // Preserve the MCP form/URL vocabulary for native host review. This is
+      // question metadata, not an approval decision or host execution authority.
+      ...(event.metadata?.kind === "mcp_elicitation"
+        ? {
+            metadata: {
+              kind: "mcp_elicitation",
+              mode: event.metadata.mode || "form",
+              server: event.metadata.server ?? null,
+              requestedSchema: event.metadata.requestedSchema ?? null,
+              url: event.metadata.url ?? null,
+              elicitationId: event.metadata.elicitationId ?? null,
+            },
+          }
+        : {}),
       expiresAt: new Date(this.now() + this.requestTimeoutMs).toISOString(),
     };
   }

package/src/lib/background-agent-supervisor.js

@@ -2174,14 +2174,22 @@ function isBackgroundAgentAfterCursor(state, cursor) {
   return String(state.id).localeCompare(cursor.id) > 0;
 }
 
+function observeBackgroundAgentList(options, source, entryCount) {
+  // Optional in-process measurement only; telemetry failures cannot change a read.
+  try {
+    options.indexObserver?.(Object.freeze({ source, entryCount }));
+  } catch {
+    // Keep observers outside the authoritative result.
+  }
+}
+
 /**
  * Return one stable, bounded page from the newest-first background session
  * feed. The cursor is an opaque ordering fence, not an authority token.
  *
- * State files are still read to preserve the current authoritative lifecycle
- * reconciliation. A future read-only index may reduce that I/O, but this API
- * immediately bounds the object graph and protocol response retained by a
- * caller.
+ * The index still enumerates and stats every authority file; selected rows are
+ * read again for lifecycle reconciliation. It reduces content reads, not the
+ * O(N) inventory fence. indexObserver receives the chosen read path and count.
  */
 export function listBackgroundAgentsPage(options = {}) {
   const limit = normalizeBackgroundAgentPageLimit(options.limit);
@@ -2223,6 +2231,7 @@ export function listBackgroundAgentsPage(options = {}) {
       projected.length > sessions.length
         ? encodeBackgroundAgentPageCursor(sessions.at(-1), options.all)
         : null;
+    observeBackgroundAgentList(options, indexed.source, indexed.entries.length);
     return Object.freeze({
       sessions: Object.freeze(sessions),
       nextCursor,
@@ -2238,6 +2247,7 @@ export function listBackgroundAgentsPage(options = {}) {
     eligible.length > sessions.length
       ? encodeBackgroundAgentPageCursor(sessions.at(-1), options.all)
       : null;
+  observeBackgroundAgentList(options, "full-scan", eligible.length);
   return Object.freeze({
     sessions: Object.freeze(sessions),
     nextCursor,

package/src/lib/causal-observability.js

@@ -8,6 +8,10 @@
 
 import crypto from "node:crypto";
 import { PRICE_TABLE, priceRollup } from "./llm-pricing.js";
+import {
+  projectUsagePricingContext,
+  mergeUsagePricingBucket,
+} from "./usage-pricing-context.js";
 import { canonicalDeliveryJson } from "./delivery-evidence.js";
 import { createSessionTranscriptStructureProjection } from "./session-transcript-structure.js";
 
@@ -251,7 +255,64 @@ function normalizePricingTable(table = PRICE_TABLE) {
       ) {
         throw new Error("pricing rates must be finite non-negative numbers");
       }
-      return { match, in: input, out: output };
+      const result = { match, in: input, out: output };
+      if (Object.hasOwn(entry, "explicitOverride")) {
+        if (typeof entry.explicitOverride !== "boolean")
+          throw new Error("pricing explicitOverride must be boolean");
+        result.explicitOverride = entry.explicitOverride;
+      }
+      if (Object.hasOwn(entry, "exact")) {
+        if (typeof entry.exact !== "boolean")
+          throw new Error("pricing exact must be boolean");
+        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),
+            ]),
+          ),
+        };
+      }
+      return result;
     });
     normalized.set(providerKey, normalizedEntries);
   }
@@ -672,6 +733,7 @@ function strictUsage(event) {
     totalTokens: expectedTotal,
     cacheReadTokens,
     cacheCreationTokens,
+    ...projectUsagePricingContext(raw),
   };
 }
 
@@ -1101,6 +1163,7 @@ export function createVerifiedSessionObservabilityProjection(
           }),
         );
         addUsageSums(row, usage, "session usage model");
+        mergeUsagePricingBucket(row, usage);
       }
 
       if (event?.type === "tool_call") {

package/src/lib/checkpoint-summary-projection.js

@@ -0,0 +1,98 @@
+import {
+  buildExtractiveHandoff,
+  formatStructuredHandoff,
+} from "../harness/structured-handoff.js";
+import {
+  DURABLE_SYSTEM_MESSAGE_KINDS,
+  getDurableSystemMessageProvenance,
+  markDurableSystemMessage,
+  projectCanonicalResumeMessages,
+} from "./session-message-provenance.js";
+
+export const HISTORY_SUMMARY_SCHEMA =
+  "chainlesschain.session-history-summary/v1";
+
+function summaryMessage(messages, action, turnId) {
+  const handoff = buildExtractiveHandoff(messages, {
+    maxFallbackSourceChars: 24_000,
+  });
+  return markDurableSystemMessage(
+    {
+      role: "system",
+      content:
+        `[Conversation Summary: ${action} ${turnId}]\n` +
+        formatStructuredHandoff(handoff),
+    },
+    DURABLE_SYSTEM_MESSAGE_KINDS.CHECKPOINT_SUMMARY,
+  );
+}
+
+/**
+ * Deterministic v1 rewrite shared by the planner and verified history reader.
+ * Source indexes describe the conservative dependency of each output, not a
+ * claim that the bounded extractive summary quotes every source. Changes to
+ * this transform/formatter require a new history schema or a v1 reader.
+ */
+export function projectCheckpointSummary({
+  messages,
+  action,
+  turnId,
+  start,
+  end,
+}) {
+  if (
+    !Array.isArray(messages) ||
+    typeof turnId !== "string" ||
+    !turnId ||
+    !Number.isSafeInteger(start) ||
+    !Number.isSafeInteger(end) ||
+    start < 0 ||
+    start >= end ||
+    end > messages.length ||
+    !["summary-from", "summary-to"].includes(action)
+  )
+    throw new TypeError("Invalid checkpoint summary source range");
+  const copied = (begin, finish) =>
+    messages.slice(begin, finish).map((message, index) => ({
+      message,
+      sourceIndexes: [begin + index],
+    }));
+  const summarized = (entries) => ({
+    message: summaryMessage(
+      entries.map((entry) => entry.message),
+      action,
+      turnId,
+    ),
+    sourceIndexes: entries.flatMap((entry) => entry.sourceIndexes),
+  });
+  if (action === "summary-from") {
+    if (end !== messages.length || messages[start]?.role !== "user")
+      throw new TypeError("Invalid checkpoint summary suffix");
+    return [...copied(0, start), summarized(copied(start, end))];
+  }
+  if (
+    start !== (messages[0]?.role === "system" ? 1 : 0) ||
+    (end < messages.length && messages[end]?.role !== "user")
+  )
+    throw new TypeError("Invalid checkpoint summary prefix");
+
+  const prefix = messages.slice(start, end);
+  // Validate/sanitize before inspecting roles. Unmarked systems must neither
+  // survive the rewrite nor be quoted into a newly authorized summary.
+  const canonical = projectCanonicalResumeMessages(prefix, { strict: true });
+  const indexes = prefix.flatMap((message, index) =>
+    message.role !== "system" || getDurableSystemMessageProvenance(message)
+      ? [start + index]
+      : [],
+  );
+  const entries = canonical.map((message, index) => ({
+    message,
+    sourceIndexes: [indexes[index]],
+  }));
+  return [
+    ...copied(0, start),
+    ...entries.filter((entry) => entry.message.role === "system"),
+    summarized(entries.filter((entry) => entry.message.role !== "system")),
+    ...copied(end, messages.length),
+  ];
+}

package/src/lib/checkpoint-timeline-authority.js

@@ -11,16 +11,7 @@ import {
   resolveCheckpointTimelineAction,
 } from "./checkpoint-timeline.js";
 import { planSessionBranch } from "./session-branch.js";
-import {
-  buildExtractiveHandoff,
-  formatStructuredHandoff,
-} from "../harness/structured-handoff.js";
-import {
-  DURABLE_SYSTEM_MESSAGE_KINDS,
-  getDurableSystemMessageProvenance,
-  markDurableSystemMessage,
-  projectCanonicalResumeMessages,
-} from "./session-message-provenance.js";
+import { projectCheckpointSummary } from "./checkpoint-summary-projection.js";
 
 export const CHECKPOINT_TIMELINE_RESULT_SCHEMA =
   "cc-checkpoint-timeline-result/v1";
@@ -243,21 +234,6 @@ function userAnchor(messages, offset) {
   return null;
 }
 
-function summaryMessage(messages, action, turnId) {
-  const handoff = buildExtractiveHandoff(messages, {
-    maxFallbackSourceChars: 24_000,
-  });
-  return markDurableSystemMessage(
-    {
-      role: "system",
-      content:
-        `[Conversation Summary: ${action} ${turnId}]\n` +
-        formatStructuredHandoff(handoff),
-    },
-    DURABLE_SYSTEM_MESSAGE_KINDS.CHECKPOINT_SUMMARY,
-  );
-}
-
 function codePreviewShape(value, checkpointId) {
   const data = value && typeof value === "object" ? value : {};
   const source = (key) => (Array.isArray(data[key]) ? data[key] : []);
@@ -348,11 +324,13 @@ export function planCheckpointTimelineAction({
     commit.messages = messages.slice(0, anchor);
     commit.bindingPruneOffset = submission.conversationOffset;
   } else if (action === CHECKPOINT_TIMELINE_ACTIONS.SUMMARY_FROM) {
-    const selected = messages.slice(anchor);
-    commit.messages = [
-      ...messages.slice(0, anchor),
-      summaryMessage(selected, action, entry.turnId),
-    ];
+    commit.summaryRange = { start: anchor, end: messages.length };
+    commit.messages = projectCheckpointSummary({
+      messages,
+      action,
+      turnId: entry.turnId,
+      ...commit.summaryRange,
+    }).map((entry) => entry.message);
     commit.bindingPruneOffset = submission.conversationOffset;
   } else if (action === CHECKPOINT_TIMELINE_ACTIONS.SUMMARY_TO) {
     const entryIndex = timeline.entries.indexOf(entry);
@@ -364,31 +342,17 @@ export function planCheckpointTimelineAction({
       return { ok: false, code: "TIMELINE_CONVERSATION_ANCHOR_STALE" };
     }
     const systemCount = messages[0]?.role === "system" ? 1 : 0;
-    const prefix = messages.slice(systemCount, nextAnchor);
-    let canonicalPrefix;
+    commit.summaryRange = { start: systemCount, end: nextAnchor };
     try {
-      canonicalPrefix = projectCanonicalResumeMessages(prefix, {
-        strict: true,
-      });
+      commit.messages = projectCheckpointSummary({
+        messages,
+        action,
+        turnId: entry.turnId,
+        ...commit.summaryRange,
+      }).map((entry) => entry.message);
     } catch {
       return { ok: false, code: "TIMELINE_CONVERSATION_INVALID" };
     }
-    const durableSystems = canonicalPrefix.filter((message) =>
-      Boolean(getDurableSystemMessageProvenance(message)),
-    );
-    // The first system is the current host-owned prompt and stays in place.
-    // Other systems survive the rewrite only with runtime provenance. An
-    // unmarked verified event must neither survive nor be quoted into the new
-    // durable summary, otherwise SUMMARY_TO would bless it on persistence.
-    const selected = canonicalPrefix.filter(
-      (message) => message.role !== "system",
-    );
-    commit.messages = [
-      ...messages.slice(0, systemCount),
-      ...durableSystems,
-      summaryMessage(selected, action, entry.turnId),
-      ...messages.slice(nextAnchor),
-    ];
     // Every surviving later offset shifts when a prefix is summarized.
     commit.bindingPruneOffset = 0;
   } else if (action === CHECKPOINT_TIMELINE_ACTIONS.BRANCH) {