zelari-code 1.38.0 → 1.42.0

package/dist/cli/main.bundled.js

@@ -1468,27 +1468,27 @@ function readStore() {
   }
   return { providers: {} };
 }
-function writeStore(store3) {
+function writeStore(store4) {
   const file2 = getKeyStorePath();
   mkdirSync2(path3.dirname(file2), { recursive: true });
-  writeFileSync2(file2, JSON.stringify(store3, null, 2), { encoding: "utf-8", mode: 384 });
+  writeFileSync2(file2, JSON.stringify(store4, null, 2), { encoding: "utf-8", mode: 384 });
 }
 function setApiKey(providerId, key) {
-  const store3 = readStore();
-  store3.providers[providerId] = { apiKey: key };
-  writeStore(store3);
+  const store4 = readStore();
+  store4.providers[providerId] = { apiKey: key };
+  writeStore(store4);
 }
 function clearApiKey(providerId) {
-  const store3 = readStore();
-  delete store3.providers[providerId];
-  writeStore(store3);
+  const store4 = readStore();
+  delete store4.providers[providerId];
+  writeStore(store4);
 }
 function getStoredApiKey(providerId) {
-  const store3 = readStore();
-  return store3.providers[providerId]?.apiKey ?? null;
+  const store4 = readStore();
+  return store4.providers[providerId]?.apiKey ?? null;
 }
 function setOAuthToken(providerId, token) {
-  const store3 = readStore();
+  const store4 = readStore();
   const entry = { apiKey: token.apiKey };
   if (typeof token.expiresAt === "number" && Number.isFinite(token.expiresAt)) {
     entry.expiresAt = token.expiresAt;
@@ -1502,12 +1502,12 @@ function setOAuthToken(providerId, token) {
   if (typeof token.idToken === "string" && token.idToken.length > 0) {
     entry.idToken = token.idToken;
   }
-  store3.providers[providerId] = entry;
-  writeStore(store3);
+  store4.providers[providerId] = entry;
+  writeStore(store4);
 }
 function getOAuthToken(providerId) {
-  const store3 = readStore();
-  return store3.providers[providerId] ?? null;
+  const store4 = readStore();
+  return store4.providers[providerId] ?? null;
 }
 function resolveApiKey(providerId) {
   const spec = getProviderSpec(providerId);
@@ -1566,8 +1566,8 @@ async function forceRefreshOAuth(providerId, options = {}) {
 function readStoreDirect() {
   return readStore();
 }
-function writeStoreDirect(store3) {
-  writeStore(store3);
+function writeStoreDirect(store4) {
+  writeStore(store4);
 }
 function maskKey(key) {
   if (key.length <= 12) return "****";
@@ -1620,9 +1620,151 @@ var init_keyStore = __esm({
   }
 });
 
+// src/cli/thinkingCapability.ts
+function thinkingCapabilityFor(id, model) {
+  const base = PROVIDER_THINKING_CAPABILITY[id] ?? {};
+  const efforts = effortLevelsFor(id, model);
+  const budget = supportsBudget(id, model);
+  return {
+    ...base,
+    effort: efforts.length > 0 || Boolean(base.effort),
+    budget,
+    efforts: efforts.length > 0 ? efforts : void 0
+  };
+}
+function effortLevelsFor(id, model) {
+  const m = (model ?? "").trim();
+  switch (id) {
+    case "grok":
+    case "openai-compatible":
+    case "custom":
+      if (grokHasXhigh(m)) return [...BASE_EFFORTS, "xhigh"];
+      return [...BASE_EFFORTS];
+    case "chatgpt":
+      if (gptHasMax(m)) return [...BASE_EFFORTS, "xhigh", "max"];
+      if (gptHasXhigh(m)) return [...BASE_EFFORTS, "xhigh"];
+      return [...BASE_EFFORTS];
+    case "deepseek":
+      return ["high", "max"];
+    case "minimax":
+      return [...BASE_EFFORTS];
+    case "glm":
+      if (glmHasEffortScale(m)) return ["low", "high", "max"];
+      return [];
+    case "anthropic":
+      if (claudeHasXhigh(m)) return ["high", "xhigh", "max"];
+      if (claudeHasMax(m)) return ["high", "max"];
+      return [];
+    default:
+      return [];
+  }
+}
+function supportsBudget(id, model) {
+  if (id === "anthropic") return true;
+  if (id === "glm") return !glmHasEffortScale(model);
+  return Boolean(PROVIDER_THINKING_CAPABILITY[id]?.budget);
+}
+function grokHasXhigh(model) {
+  const v = parseDottedVersion(model, /grok[-_]?(\d+)(?:[.-](\d+))?/i);
+  if (!v) return false;
+  return v.major > 4 || v.major === 4 && v.minor >= 6;
+}
+function gptHasXhigh(model) {
+  const v = parseDottedVersion(model, /gpt[-_]?(\d+)(?:[.-](\d+))?/i);
+  if (!v) return false;
+  return v.major > 5 || v.major === 5 && v.minor >= 4;
+}
+function gptHasMax(model) {
+  const v = parseDottedVersion(model, /gpt[-_]?(\d+)(?:[.-](\d+))?/i);
+  if (!v) return false;
+  return v.major > 5 || v.major === 5 && v.minor >= 6;
+}
+function claudeHasMax(model) {
+  const v = parseClaudeVersion(model);
+  if (!v) return false;
+  return v.major > 4 || v.major === 4 && v.minor >= 6;
+}
+function claudeHasXhigh(model) {
+  const v = parseClaudeVersion(model);
+  if (!v) return false;
+  if (v.major >= 5) return true;
+  return v.major === 4 && v.minor >= 7;
+}
+function glmHasEffortScale(model) {
+  const v = parseDottedVersion(model ?? "", /glm[-_]?(\d+)(?:[.-](\d+))?/i);
+  if (!v) return false;
+  return v.major >= 5;
+}
+function parseDottedVersion(model, re) {
+  const m = re.exec(model);
+  if (!m) return null;
+  return {
+    major: Number.parseInt(m[1], 10),
+    minor: m[2] ? Number.parseInt(m[2], 10) : 0
+  };
+}
+function parseClaudeVersion(model) {
+  const m = /claude-(?:sonnet|opus|haiku)[-_]?(\d+)(?:[.-](\d+))?/i.exec(model);
+  if (!m) return null;
+  return {
+    major: Number.parseInt(m[1], 10),
+    minor: m[2] ? Number.parseInt(m[2], 10) : 0
+  };
+}
+var THINKING_EFFORTS, BASE_EFFORTS, PROVIDER_THINKING_CAPABILITY;
+var init_thinkingCapability = __esm({
+  "src/cli/thinkingCapability.ts"() {
+    "use strict";
+    THINKING_EFFORTS = [
+      "low",
+      "medium",
+      "high",
+      "xhigh",
+      "max"
+    ];
+    BASE_EFFORTS = ["low", "medium", "high"];
+    PROVIDER_THINKING_CAPABILITY = {
+      "openai-compatible": { effort: true },
+      grok: { effort: true },
+      chatgpt: { effort: true },
+      anthropic: { budget: true },
+      glm: { budget: true },
+      deepseek: { effort: true },
+      minimax: { effort: true },
+      custom: { effort: true }
+    };
+  }
+});
+
 // src/cli/thinking.ts
-function thinkingCapabilityFor(id) {
-  return PROVIDER_THINKING_CAPABILITY[id] ?? {};
+function clampEffort(id, model, requested) {
+  const native = effortLevelsFor(id, model);
+  if (native.includes(requested)) {
+    return { effort: requested, clamped: false };
+  }
+  if (native.length === 0) {
+    return {
+      effort: requested,
+      clamped: true,
+      note: `thinking '${requested}' is not supported for provider "${id}"`
+    };
+  }
+  const want = EFFORT_RANK[requested];
+  let best = native[0];
+  let bestDist = Math.abs(EFFORT_RANK[best] - want);
+  for (const level of native) {
+    const dist = Math.abs(EFFORT_RANK[level] - want);
+    if (dist < bestDist || dist === bestDist && EFFORT_RANK[level] > EFFORT_RANK[best]) {
+      best = level;
+      bestDist = dist;
+    }
+  }
+  const label = model ? `${id}/${model}` : id;
+  return {
+    effort: best,
+    clamped: true,
+    note: `'${requested}' is not native on ${label} \u2014 using '${best}'`
+  };
 }
 function stringifyThinkingSpec(spec) {
   if (spec === "auto") return "auto";
@@ -1634,7 +1776,9 @@ function parseThinkingSpec(raw) {
   const s = (raw ?? "").trim().toLowerCase();
   if (!s || s === "auto") return "auto";
   if (s === "off") return { kind: "off" };
-  if (s === "low" || s === "medium" || s === "high") return { kind: "effort", effort: s };
+  if (THINKING_EFFORTS.includes(s)) {
+    return { kind: "effort", effort: s };
+  }
   const m = /^budget:(\d+)$/.exec(s);
   if (m) {
     const n = Number.parseInt(m[1], 10);
@@ -1644,15 +1788,19 @@ function parseThinkingSpec(raw) {
 }
 function isValidThinkingInput(raw) {
   const s = raw.trim().toLowerCase();
-  if (s === "auto" || s === "off" || s === "low" || s === "medium" || s === "high") return true;
+  if (s === "auto" || s === "off") return true;
+  if (THINKING_EFFORTS.includes(s)) return true;
   return /^budget:\d+$/.test(s) && Number.parseInt(s.slice(7), 10) > 0;
 }
 function degrade(note) {
   return { patch: {}, degraded: true, note };
 }
-function translateOpenAiCompatibleThinking(providerId, spec) {
+function withClampNote(patch, clamped, note) {
+  return { patch, degraded: false, note: clamped ? note : void 0 };
+}
+function translateOpenAiCompatibleThinking(providerId, spec, model) {
   if (spec === "auto") return { patch: {}, degraded: false };
-  const cap3 = thinkingCapabilityFor(providerId);
+  const cap3 = thinkingCapabilityFor(providerId, model);
   switch (spec.kind) {
     case "off":
       if (providerId === "deepseek" || providerId === "glm") {
@@ -1660,20 +1808,40 @@ function translateOpenAiCompatibleThinking(providerId, spec) {
       }
       if (cap3.effort) return { patch: { reasoning_effort: "low" }, degraded: false };
       return degrade(`thinking 'off' is not supported for provider "${providerId}"`);
-    case "effort":
-      if (!cap3.effort) {
+    case "effort": {
+      if (!cap3.effort && !cap3.efforts?.length) {
         return degrade(`thinking 'effort' is not supported for provider "${providerId}"`);
       }
+      const resolved = clampEffort(providerId, model, spec.effort);
       if (providerId === "deepseek") {
-        return {
-          patch: {
+        return withClampNote(
+          {
             thinking: { type: "enabled" },
-            reasoning_effort: spec.effort === "high" ? "max" : "high"
+            reasoning_effort: resolved.effort === "max" ? "max" : "high"
           },
-          degraded: false
-        };
+          resolved.clamped,
+          resolved.note
+        );
+      }
+      if (providerId === "glm") {
+        if (!glmHasEffortScale(model)) {
+          return degrade(`thinking 'effort' is not supported for GLM ${model || "4.x"} \u2014 use budget:N`);
+        }
+        return withClampNote(
+          {
+            thinking: { type: "enabled" },
+            reasoning_effort: resolved.effort
+          },
+          resolved.clamped,
+          resolved.note
+        );
       }
-      return { patch: { reasoning_effort: spec.effort }, degraded: false };
+      return withClampNote(
+        { reasoning_effort: resolved.effort },
+        resolved.clamped,
+        resolved.note
+      );
+    }
     case "budget":
       if (!cap3.budget) {
         return degrade(`thinking 'budget' is not supported for provider "${providerId}"`);
@@ -1684,18 +1852,24 @@ function translateOpenAiCompatibleThinking(providerId, spec) {
       };
   }
 }
-function translateResponsesThinking(spec) {
+function translateResponsesThinking(spec, model) {
   if (spec === "auto") return { patch: {}, degraded: false };
   switch (spec.kind) {
     case "off":
       return { patch: { reasoning: { effort: "minimal" } }, degraded: false };
-    case "effort":
-      return { patch: { reasoning: { effort: spec.effort } }, degraded: false };
+    case "effort": {
+      const resolved = clampEffort("chatgpt", model, spec.effort);
+      return withClampNote(
+        { reasoning: { effort: resolved.effort } },
+        resolved.clamped,
+        resolved.note
+      );
+    }
     case "budget":
-      return degrade('thinking "budget" is not supported for chatgpt \u2014 use low/medium/high');
+      return degrade('thinking "budget" is not supported for chatgpt \u2014 use low/medium/high/xhigh/max');
   }
 }
-function translateAnthropicThinking(spec) {
+function translateAnthropicThinking(spec, model) {
   if (spec === "auto") return { patch: {}, degraded: false };
   switch (spec.kind) {
     case "off":
@@ -1705,23 +1879,31 @@ function translateAnthropicThinking(spec) {
         patch: { thinking: { type: "enabled", budget_tokens: spec.budgetTokens } },
         degraded: false
       };
-    case "effort":
-      return degrade('thinking "effort" is not supported for anthropic \u2014 use budget:N');
+    case "effort": {
+      const levels = effortLevelsFor("anthropic", model);
+      if (levels.length === 0) {
+        return degrade('thinking "effort" is not supported for this Claude model \u2014 use budget:N');
+      }
+      const resolved = clampEffort("anthropic", model, spec.effort);
+      return withClampNote(
+        { output_config: { effort: resolved.effort } },
+        resolved.clamped,
+        resolved.note
+      );
+    }
   }
 }
-var PROVIDER_THINKING_CAPABILITY;
+var EFFORT_RANK;
 var init_thinking = __esm({
   "src/cli/thinking.ts"() {
     "use strict";
-    PROVIDER_THINKING_CAPABILITY = {
-      "openai-compatible": { effort: true },
-      "grok": { effort: true },
-      "chatgpt": { effort: true },
-      "anthropic": { budget: true },
-      "glm": { budget: true },
-      "deepseek": { effort: true },
-      "minimax": { effort: true },
-      "custom": { effort: true }
+    init_thinkingCapability();
+    EFFORT_RANK = {
+      low: 1,
+      medium: 2,
+      high: 3,
+      xhigh: 4,
+      max: 5
     };
   }
 });
@@ -1914,14 +2096,14 @@ var init_providerConfig = __esm({
     DEFAULTS = {
       activeProviderId: "openai-compatible",
       modelByProvider: {
-        // grok-4.5: flagship; reasoning_effort defaults to "high" on the xAI API
-        "openai-compatible": "grok-4.5",
+        // grok-4.6: flagship; native reasoning_effort includes xhigh
+        "openai-compatible": "grok-4.6",
         "minimax": "MiniMax-M2.5",
         "glm": "glm-4.6",
-        "grok": "grok-4.5",
+        "grok": "grok-4.6",
         "deepseek": "deepseek-v4-pro",
-        "chatgpt": "gpt-5.2-codex",
-        "anthropic": "claude-sonnet-4-5",
+        "chatgpt": "gpt-5.6-codex",
+        "anthropic": "claude-sonnet-4-6",
         "custom": ""
       },
       thinkingByProvider: {
@@ -1948,6 +2130,7 @@ __export(modelDiscovery_exports, {
   getCachedModels: () => getCachedModels,
   getDiscoveredModelIds: () => getDiscoveredModelIds,
   getModelsFilePath: () => getModelsFilePath,
+  getStaticFallbackModels: () => getStaticFallbackModels,
   isModelsCacheStale: () => isModelsCacheStale,
   loadModelsRegistry: () => loadModelsRegistry,
   pickDefaultModel: () => pickDefaultModel
@@ -1955,6 +2138,9 @@ __export(modelDiscovery_exports, {
 import { promises as fs3, existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
 import { homedir } from "node:os";
 import path5 from "node:path";
+function getStaticFallbackModels(provider) {
+  return STATIC_FALLBACKS[provider] ? [...STATIC_FALLBACKS[provider]] : [];
+}
 async function resolveDiscoveryBaseUrl(provider, options) {
   if (options.baseUrl) return options.baseUrl;
   const { getCustomEndpoint: getCustomEndpoint2 } = await Promise.resolve().then(() => (init_providerConfig(), providerConfig_exports));
@@ -2090,10 +2276,6 @@ async function discoverModelsForProvider(provider, options = {}) {
     const headers2 = await resolveDiscoveryHeaders(provider, authToken);
     response = await fetchImpl(url2, { method: "GET", headers: headers2 });
   } catch (err) {
-    const fallback = STATIC_FALLBACKS[provider];
-    if (fallback) {
-      return cacheFallback(provider, baseUrl, fallback, options, `network: ${err instanceof Error ? err.message : String(err)}`);
-    }
     throw new ModelDiscoveryError(
       `Network error contacting ${url2}: ${err instanceof Error ? err.message : String(err)}`,
       "network_error"
@@ -2101,10 +2283,6 @@ async function discoverModelsForProvider(provider, options = {}) {
   }
   if (!response.ok) {
     const body = await response.text().catch(() => "");
-    const fallback = STATIC_FALLBACKS[provider];
-    if (fallback) {
-      return cacheFallback(provider, baseUrl, fallback, options, `HTTP ${response.status}: ${body.slice(0, 80)}`);
-    }
     throw new ModelDiscoveryError(
       `HTTP ${response.status} from ${url2}: ${body.slice(0, 200)}`,
       `http_${response.status}`
@@ -2114,10 +2292,6 @@ async function discoverModelsForProvider(provider, options = {}) {
   try {
     json2 = await response.json();
   } catch (err) {
-    const fallback = STATIC_FALLBACKS[provider];
-    if (fallback) {
-      return cacheFallback(provider, baseUrl, fallback, options, "invalid_json");
-    }
     throw new ModelDiscoveryError(
       `Invalid JSON from ${url2}: ${err instanceof Error ? err.message : String(err)}`,
       "invalid_json"
@@ -2125,10 +2299,6 @@ async function discoverModelsForProvider(provider, options = {}) {
   }
   const models = provider === "anthropic" ? parseAnthropicModelsResponse(json2) : parseOpenAIModelsResponse(json2, baseUrl);
   if (models.length === 0) {
-    const fallback = STATIC_FALLBACKS[provider];
-    if (fallback) {
-      return cacheFallback(provider, baseUrl, fallback, options, "empty_response");
-    }
     throw new ModelDiscoveryError(
       `Provider ${provider} returned 0 models \u2014 refusing to overwrite cache`,
       "empty_response"
@@ -2148,22 +2318,6 @@ async function discoverModelsForProvider(provider, options = {}) {
   }
   return entry;
 }
-async function cacheFallback(provider, baseUrl, models, options, lastError) {
-  const entry = {
-    models,
-    fetchedAt: Date.now(),
-    baseUrl,
-    lastError
-  };
-  if (!options.skipCacheWrite) {
-    const file2 = getModelsFilePath();
-    await readModifyWriteRegistry((current) => {
-      current[provider] = entry;
-      return current;
-    }, file2);
-  }
-  return entry;
-}
 function discoverModelsInBackground(provider, options = {}) {
   discoverModelsForProvider(provider, options).catch((err) => {
     if (err instanceof ModelDiscoveryError && options.onError) {
@@ -2201,6 +2355,9 @@ var init_modelDiscovery = __esm({
     };
     STATIC_FALLBACKS = {
       chatgpt: [
+        { id: "gpt-5.6-codex", displayName: "GPT-5.6 Codex" },
+        { id: "gpt-5.6", displayName: "GPT-5.6" },
+        { id: "gpt-5.4", displayName: "GPT-5.4" },
         { id: "gpt-5.2-codex", displayName: "GPT-5.2 Codex" },
         { id: "gpt-5.2", displayName: "GPT-5.2" },
         { id: "gpt-5.1-codex", displayName: "GPT-5.1 Codex" },
@@ -2209,9 +2366,19 @@ var init_modelDiscovery = __esm({
         { id: "o4-mini", displayName: "o4-mini" }
       ],
       anthropic: [
+        { id: "claude-opus-4-7", displayName: "Claude Opus 4.7" },
         { id: "claude-opus-4-6", displayName: "Claude Opus 4.6" },
+        { id: "claude-sonnet-4-6", displayName: "Claude Sonnet 4.6" },
         { id: "claude-sonnet-4-5", displayName: "Claude Sonnet 4.5" },
         { id: "claude-haiku-4-5", displayName: "Claude Haiku 4.5" }
+      ],
+      grok: [
+        { id: "grok-4.6", displayName: "Grok 4.6" },
+        { id: "grok-4.5", displayName: "Grok 4.5" }
+      ],
+      glm: [
+        { id: "glm-5.3", displayName: "GLM-5.3" },
+        { id: "glm-4.6", displayName: "GLM-4.6" }
       ]
     };
     writeChain = Promise.resolve();
@@ -21047,6 +21214,79 @@ var init_types = __esm({
   }
 });
 
+// packages/core/dist/core/requestSnapshot.js
+import { createHash as createHash2 } from "node:crypto";
+function stableStringify(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value) ?? "null";
+  if (Array.isArray(value)) {
+    const items = value.map((v) => stableStringify(v));
+    return `[${items.join(",")}]`;
+  }
+  const obj = value;
+  const keys = Object.keys(obj).filter((k) => obj[k] !== void 0).sort();
+  const parts = keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`);
+  return `{${parts.join(",")}}`;
+}
+function sha256Hex(input) {
+  return createHash2("sha256").update(input, "utf8").digest("hex").slice(0, 32);
+}
+function cloneMessages(messages) {
+  return structuredClone(messages);
+}
+function canonicalTools(tools) {
+  return [...tools].sort((a, b) => a.name.localeCompare(b.name));
+}
+function createRoutedRequestSnapshot(params) {
+  let split = 0;
+  while (split < params.messages.length && params.messages[split].role === "system") {
+    split++;
+  }
+  const systemMessages = cloneMessages(params.messages.slice(0, split));
+  const conversation = cloneMessages(params.messages.slice(split));
+  const tools = canonicalTools(params.tools).map((t) => structuredClone(t));
+  const header = stableStringify({
+    provider: params.provider,
+    model: params.model,
+    systemMessages,
+    tools
+  });
+  const request = stableStringify({
+    provider: params.provider,
+    model: params.model,
+    systemMessages,
+    tools,
+    conversation
+  });
+  return {
+    provider: params.provider,
+    model: params.model,
+    systemMessages,
+    conversation,
+    tools,
+    headerFingerprint: sha256Hex(header),
+    requestFingerprint: sha256Hex(request),
+    createdAt: Date.now()
+  };
+}
+function compareReplayPrefix(snapshot, messages) {
+  const base = snapshot.conversation;
+  const n = Math.min(base.length, messages.length);
+  let matching = 0;
+  for (let i = 0; i < n; i++) {
+    if (stableStringify(base[i]) !== stableStringify(messages[i])) {
+      return { exact: false, matchingMessages: matching, mismatchIndex: i };
+    }
+    matching++;
+  }
+  return { exact: true, matchingMessages: matching };
+}
+var init_requestSnapshot = __esm({
+  "packages/core/dist/core/requestSnapshot.js"() {
+    "use strict";
+  }
+});
+
 // packages/core/dist/core/textLoopDetect.js
 function isStatusTheaterUnit(unit) {
   const u = normalizeLoopUnit(unit).toLowerCase();
@@ -21245,10 +21485,10 @@ var init_textLoopDetect = __esm({
 
 // packages/core/dist/core/AgentHarness.js
 function hashToolCall(toolName, args) {
-  const canonical = stableStringify(args);
+  const canonical = stableStringify2(args);
   return `${toolName}::${canonical}`;
 }
-function stableStringify(value) {
+function stableStringify2(value) {
   return JSON.stringify(value, (_k, v) => {
     if (v && typeof v === "object" && !Array.isArray(v)) {
       const sorted = {};
@@ -21481,6 +21721,7 @@ var init_AgentHarness = __esm({
   "packages/core/dist/core/AgentHarness.js"() {
     "use strict";
     init_events();
+    init_requestSnapshot();
     init_textLoopDetect();
     init_textLoopDetect();
     AgentHarness = class {
@@ -21917,6 +22158,23 @@ ${shared2.content}`,
         yield agentEnd;
         this.activeController = null;
       }
+      /**
+       * v1.36.0: capture a deterministic snapshot of the routed request just
+       * before it goes out. Never throws into the request path.
+       */
+      emitSnapshot(tools, generation) {
+        if (!this.config.onRequestSnapshot)
+          return;
+        try {
+          this.config.onRequestSnapshot(createRoutedRequestSnapshot({
+            messages: this.config.messages,
+            model: this.config.model,
+            provider: this.config.provider,
+            tools
+          }), generation);
+        } catch {
+        }
+      }
       /**
        * Run a single provider turn for the current message buffer.
        * Streams from the provider, dispatches deltas to events, executes
@@ -21934,6 +22192,7 @@ ${shared2.content}`,
        */
       async *runSingleTurn(messageId, finishRef, usageRef) {
         try {
+          this.emitSnapshot(this.config.tools);
           const stream = this.config.providerStream({
             messages: this.config.messages,
             model: this.config.model,
@@ -22224,6 +22483,7 @@ ${cached2}`
         const finishRef = { value: "stop" };
         const usageRef = { value: null };
         try {
+          this.emitSnapshot([]);
           const stream = this.config.providerStream({
             messages: this.config.messages,
             model: this.config.model,
@@ -22804,7 +23064,10 @@ __export(harness_exports, {
   SessionJsonlWriter: () => SessionJsonlWriter,
   TEXT_LOOP_RECOVERY_SYSTEM: () => TEXT_LOOP_RECOVERY_SYSTEM,
   TEXT_LOOP_RECOVERY_USER_PROMPT: () => TEXT_LOOP_RECOVERY_USER_PROMPT,
+  canonicalTools: () => canonicalTools,
   collapseLoopedAssistantText: () => collapseLoopedAssistantText,
+  compareReplayPrefix: () => compareReplayPrefix,
+  createRoutedRequestSnapshot: () => createRoutedRequestSnapshot,
   detectAssistantTextLoop: () => detectAssistantTextLoop,
   detectAssistantTextLoopWindow: () => detectAssistantTextLoopWindow,
   hashToolCall: () => hashToolCall,
@@ -22816,6 +23079,8 @@ __export(harness_exports, {
   parseMinimaxStyleToolCalls: () => parseMinimaxStyleToolCalls,
   parseTextToolCalls: () => parseTextToolCalls,
   readSession: () => readSession,
+  sha256Hex: () => sha256Hex,
+  stableStringify: () => stableStringify,
   toolMatches: () => toolMatches,
   wrapLegacyStream: () => wrapLegacyStream
 });
@@ -22824,6 +23089,7 @@ var init_harness = __esm({
     "use strict";
     init_AgentHarness();
     init_providerStream();
+    init_requestSnapshot();
     init_sessionJsonl();
     init_hooks();
   }
@@ -27735,6 +28001,7 @@ __export(dist_exports, {
   buildSystemPrompt: () => buildSystemPrompt,
   buildSystemPromptSplit: () => buildSystemPromptSplit,
   canRunParallel: () => canRunParallel,
+  canonicalTools: () => canonicalTools,
   captureFailure: () => captureFailure,
   checkImplementationCompletion: () => checkImplementationCompletion,
   checkImplementationDelivery: () => checkImplementationDelivery,
@@ -27746,6 +28013,7 @@ __export(dist_exports, {
   clearCustomTools: () => clearCustomTools,
   cliToolToEnhanced: () => cliToolToEnhanced,
   collapseLoopedAssistantText: () => collapseLoopedAssistantText,
+  compareReplayPrefix: () => compareReplayPrefix,
   computeAgentSkills: () => computeAgentSkills,
   computeAgentTools: () => computeAgentTools,
   councilModeBanner: () => councilModeBanner,
@@ -27755,6 +28023,7 @@ __export(dist_exports, {
   createBrainEvent: () => createBrainEvent,
   createDefaultSystemPromptConfig: () => createDefaultSystemPromptConfig,
   createGraph: () => createGraph,
+  createRoutedRequestSnapshot: () => createRoutedRequestSnapshot,
   defaultPersonaParse: () => defaultPersonaParse,
   detectAssistantTextLoop: () => detectAssistantTextLoop,
   detectAssistantTextLoopWindow: () => detectAssistantTextLoopWindow,
@@ -27871,9 +28140,11 @@ __export(dist_exports, {
   scrubProprietaryLeak: () => scrubProprietaryLeak,
   selectParallelWave: () => selectParallelWave,
   setWorkspaceStubs: () => setWorkspaceStubs,
+  sha256Hex: () => sha256Hex,
   shouldRetryMember: () => shouldRetryMember,
   slugify: () => slugify2,
   specificityFromAssumptions: () => specificityFromAssumptions,
+  stableStringify: () => stableStringify,
   stripClarificationProtocol: () => stripClarificationProtocol,
   swapMembers: () => swapMembers,
   systemMessagesFromSplit: () => systemMessagesFromSplit,
@@ -28236,6 +28507,7 @@ function openaiCompatibleProvider(config2) {
       if (cacheable) messageMappingCache.set(m, mapped);
       return mapped;
     });
+    const generation = params.generation;
     const body = {
       // Use `params.model` (per-call override from AgentHarness, e.g. for
       // `agentModels` config) rather than the closed-over `config.model`
@@ -28243,7 +28515,7 @@ function openaiCompatibleProvider(config2) {
       model: params.model,
       messages,
       stream: true,
-      temperature: 0.7,
+      temperature: generation?.temperature ?? 0.7,
       // Task G.4.2 — request the provider to send real token usage in
       // the final chunk (gated by `stream_options.include_usage` on the
       // OpenAI-compatible API). Providers that don't honor this (some
@@ -28251,13 +28523,16 @@ function openaiCompatibleProvider(config2) {
       // the harness will fall back to the ~4-char/token approximation.
       stream_options: { include_usage: true }
     };
+    if (typeof generation?.maxTokens === "number" && generation.maxTokens > 0) {
+      body.max_tokens = generation.maxTokens;
+    }
     const thinkingSpec = config2.thinking ?? "auto";
     if (config2.providerId === "deepseek" && thinkingSpec === "auto") {
       const thinking = resolveDeepSeekThinking();
       if (thinking.thinking) body.thinking = { type: thinking.thinking };
       if (thinking.reasoningEffort) body.reasoning_effort = thinking.reasoningEffort;
     } else if (thinkingSpec !== "auto") {
-      const t = translateOpenAiCompatibleThinking(config2.providerId, thinkingSpec);
+      const t = translateOpenAiCompatibleThinking(config2.providerId, thinkingSpec, config2.model);
       if (t.degraded) {
         console.warn(`[thinking] ${t.note ?? "unsupported"} \u2014 falling back to provider default.`);
       } else {
@@ -28791,7 +29066,7 @@ function anthropicMessagesProvider(config2) {
     }
     const thinkingSpec = config2.thinking ?? "auto";
     if (thinkingSpec !== "auto") {
-      const t = translateAnthropicThinking(thinkingSpec);
+      const t = translateAnthropicThinking(thinkingSpec, config2.model);
       if (t.degraded) console.warn(`[thinking] ${t.note ?? "unsupported"} \u2014 falling back to provider default.`);
       else Object.assign(body, t.patch);
     }
@@ -29003,7 +29278,7 @@ function chatgptResponsesProvider(config2) {
     }
     const thinkingSpec = config2.thinking ?? "auto";
     if (thinkingSpec !== "auto") {
-      const t = translateResponsesThinking(thinkingSpec);
+      const t = translateResponsesThinking(thinkingSpec, config2.model);
       if (t.degraded) console.warn(`[thinking] ${t.note ?? "unsupported"} \u2014 falling back to provider default.`);
       else Object.assign(body, t.patch);
     }
@@ -29145,7 +29420,7 @@ var init_resolveStream = __esm({
 });
 
 // packages/core/dist/core/tools/toolOutputSpill.js
-import { createHash as createHash2, randomBytes as randomBytes2 } from "node:crypto";
+import { createHash as createHash3, randomBytes as randomBytes2 } from "node:crypto";
 import { existsSync as existsSync12, mkdirSync as mkdirSync7, writeFileSync as writeFileSync11 } from "node:fs";
 import { homedir as homedir3, tmpdir } from "node:os";
 import { join as join11 } from "node:path";
@@ -29175,7 +29450,7 @@ function spillToolOutput(fullText, meta3) {
     if (!existsSync12(dir)) {
       mkdirSync7(dir, { recursive: true });
     }
-    const hash3 = createHash2("sha256").update(fullText).digest("hex").slice(0, 12);
+    const hash3 = createHash3("sha256").update(fullText).digest("hex").slice(0, 12);
     const stamp = Date.now().toString(36);
     const rnd = randomBytes2(3).toString("hex");
     const safeTool = (meta3?.toolName ?? "tool").replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 32);
@@ -31582,9 +31857,9 @@ var init_store = __esm({
 import { promises as fs12, existsSync as existsSync17, readFileSync as readFileSync17 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
 import path23 from "node:path";
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 function getIndexPath(root) {
-  const hash3 = createHash3("sha1").update(path23.resolve(root)).digest("hex").slice(0, 16);
+  const hash3 = createHash4("sha1").update(path23.resolve(root)).digest("hex").slice(0, 16);
   return process.env.ZELARI_SEMANTIC_FILE ?? path23.join(homedir5(), ".tmp", "zelari-code", "semantic", `${hash3}.json`);
 }
 async function collectSourceFiles(root, maxFiles = 1500) {
@@ -33065,11 +33340,11 @@ function readStore3() {
     return DEFAULT_STORE;
   }
 }
-function writeStore3(store3) {
+function writeStore3(store4) {
   const p3 = trustStorePath();
   try {
     mkdirSync11(path28.dirname(p3), { recursive: true });
-    writeFileSync13(p3, JSON.stringify(store3, null, 2), "utf8");
+    writeFileSync13(p3, JSON.stringify(store4, null, 2), "utf8");
   } catch (err) {
     throw new Error(
       `failed to persist trust store ${p3}: ${err instanceof Error ? err.message : String(err)}`
@@ -33093,21 +33368,21 @@ function isFolderTrusted(folderPath) {
   return readStore3().folders.some((f) => normalize(f.path) === target);
 }
 function trustFolder(folderPath) {
-  const store3 = readStore3();
+  const store4 = readStore3();
   const normalized = path28.resolve(folderPath);
-  if (!store3.folders.some((f) => normalize(f.path) === normalize(normalized))) {
-    store3.folders.push({ path: normalized, trustedAt: (/* @__PURE__ */ new Date()).toISOString() });
-    writeStore3(store3);
+  if (!store4.folders.some((f) => normalize(f.path) === normalize(normalized))) {
+    store4.folders.push({ path: normalized, trustedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    writeStore3(store4);
   }
   return { ok: true, path: normalized };
 }
 function untrustFolder(folderPath) {
-  const store3 = readStore3();
+  const store4 = readStore3();
   const target = normalize(folderPath);
-  const before = store3.folders.length;
-  store3.folders = store3.folders.filter((f) => normalize(f.path) !== target);
-  if (store3.folders.length === before) return { ok: true, removed: false };
-  writeStore3(store3);
+  const before = store4.folders.length;
+  store4.folders = store4.folders.filter((f) => normalize(f.path) !== target);
+  if (store4.folders.length === before) return { ok: true, removed: false };
+  writeStore3(store4);
   return { ok: true, removed: true };
 }
 function listTrustedFolders() {
@@ -33208,7 +33483,7 @@ var init_lifecycleHooks = __esm({
 });
 
 // src/cli/toolResultCache.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import { promises as fs14 } from "node:fs";
 import path29 from "node:path";
 function isToolCacheEnabled() {
@@ -33221,7 +33496,7 @@ function resolveToolCacheTtlMs() {
   return Number.isFinite(n) && n >= 0 ? n : TOOL_CACHE_DEFAULT_TTL_MS;
 }
 function hashKey(parts) {
-  return createHash4("sha256").update(JSON.stringify(parts), "utf8").digest("hex");
+  return createHash5("sha256").update(JSON.stringify(parts), "utf8").digest("hex");
 }
 function resultBytes(result) {
   try {
@@ -33902,7 +34177,7 @@ var init_toolRegistry = __esm({
 });
 
 // src/cli/state/fileStateStore.ts
-import { createHash as createHash5, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash6, randomUUID as randomUUID2 } from "node:crypto";
 import { promises as fs15 } from "node:fs";
 import * as path30 from "node:path";
 function shortId() {
@@ -33945,16 +34220,16 @@ function isStateEnabled(env = process.env) {
 }
 async function getStateStore(projectRoot, env = process.env) {
   if (!isStateEnabled(env)) return new NoopDurableStateStore();
-  const store3 = new FileDurableStateStore();
+  const store4 = new FileDurableStateStore();
   try {
-    await store3.init(projectRoot);
-    return store3;
+    await store4.init(projectRoot);
+    return store4;
   } catch {
     return new NoopDurableStateStore();
   }
 }
 function hashStablePrompt(stable) {
-  return createHash5("sha256").update(stable, "utf8").digest("hex").slice(0, 16);
+  return createHash6("sha256").update(stable, "utf8").digest("hex").slice(0, 16);
 }
 var DEFAULT_MATERIALIZE_CHARS, FileDurableStateStore, NoopDurableStateStore;
 var init_fileStateStore = __esm({
@@ -34285,29 +34560,6 @@ function extractiveHistorySummary(dropped, opts) {
   }
   return out;
 }
-function formatDroppedForLlm(dropped) {
-  const lines = [];
-  for (const m of dropped) {
-    if (m.role === "user") {
-      lines.push(`USER: ${oneLine(m.content, 400)}`);
-    } else if (m.role === "assistant") {
-      const tools = m.toolCalls?.map((t) => t.name).join(",") || "";
-      const body2 = oneLine(m.content, 300);
-      lines.push(
-        tools ? `ASSISTANT(tools=${tools}): ${body2}` : `ASSISTANT: ${body2}`
-      );
-    } else if (m.role === "tool") {
-      lines.push(`TOOL(${m.toolCallId ?? "?"}): ${oneLine(m.content, 160)}`);
-    } else if (m.role === "system") {
-      lines.push(`SYSTEM: ${oneLine(m.content, 200)}`);
-    }
-  }
-  let body = lines.join("\n");
-  if (body.length > MAX_LLM_INPUT_CHARS) {
-    body = body.slice(body.length - MAX_LLM_INPUT_CHARS);
-  }
-  return body;
-}
 function oneLine(s, max) {
   const t = s.replace(/\s+/g, " ").trim();
   if (t.length <= max) return t;
@@ -34333,12 +34585,11 @@ function collectPathsFromText(text, out) {
     n += 1;
   }
 }
-var MAX_SUMMARY_CHARS, MAX_LLM_INPUT_CHARS;
+var MAX_SUMMARY_CHARS;
 var init_historySummary = __esm({
   "src/cli/budget/historySummary.ts"() {
     "use strict";
     MAX_SUMMARY_CHARS = 3500;
-    MAX_LLM_INPUT_CHARS = 24e3;
   }
 });
 
@@ -34348,92 +34599,87 @@ function isLlmCompactEnabled() {
   if (v === "0" || v === "false" || v === "off" || v === "no") return false;
   return true;
 }
-async function llmSummarizeHistory(input) {
-  if (!isLlmCompactEnabled()) return null;
-  if (!input.droppedTranscript.trim()) return null;
-  let config2 = null;
-  try {
-    config2 = await resolveCompactProviderConfig();
-  } catch {
-    return null;
+function compactModelOverride() {
+  const v = process.env.ZELARI_COMPACT_MODEL?.trim();
+  return v ? v : void 0;
+}
+async function llmSummarizeHistoryReplay(input) {
+  const override = input.overrideModel ?? compactModelOverride();
+  const model = override ?? input.model;
+  const cacheReuseExpected = !override;
+  if (!isLlmCompactEnabled()) return { summary: null, model, cacheReuseExpected };
+  if (input.droppedMessages.length === 0) {
+    return { summary: null, model, cacheReuseExpected };
   }
-  if (!config2) return null;
-  const model = process.env.ZELARI_COMPACT_MODEL?.trim() || config2.model;
+  const messages = [
+    ...input.systemMessages,
+    ...input.droppedMessages,
+    {
+      role: "user",
+      content: COMPACTION_INSTRUCTION
+    }
+  ];
   const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), 45e3);
+  const timeout = setTimeout(() => controller.abort(), REPLAY_TIMEOUT_MS);
   const onOuterAbort = () => controller.abort();
   input.signal?.addEventListener("abort", onOuterAbort, { once: true });
   try {
-    const url2 = `${config2.baseUrl.replace(/\/$/, "")}/chat/completions`;
-    const res = await fetch(url2, {
-      method: "POST",
+    let text = "";
+    let emittedToolCall = false;
+    for await (const delta of input.providerStream({
+      provider: input.provider,
+      model,
+      messages,
+      // Tools stay advertised: dropping them would change the prefix token
+      // sequence and destroy cache reuse (explicit DSH decision). They are
+      // sorted canonically (same discipline as the live routed request and
+      // the snapshot fingerprints) so the replay prefix is byte-identical.
+      tools: [...input.tools].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0),
       signal: controller.signal,
-      headers: {
-        "content-type": "application/json",
-        authorization: `Bearer ${config2.apiKey}`
-      },
-      body: JSON.stringify({
-        model,
+      generation: {
+        purpose: "compaction",
         temperature: 0.1,
-        max_tokens: 900,
-        stream: false,
-        messages: [
-          { role: "system", content: COMPACT_SYSTEM },
-          {
-            role: "user",
-            content: `Extractive sketch (may be incomplete):
-${input.extractive.slice(0, 2500)}
-
-Transcript of dropped turns:
-${input.droppedTranscript}`
-          }
-        ]
-      })
-    });
-    if (!res.ok) return null;
-    const json2 = await res.json();
-    const text = json2.choices?.[0]?.message?.content?.trim();
-    if (!text) return null;
-    return "[history-summary \xB7 llm]\n" + text + "\n\nContinue from the recent messages below; honor decisions already made above.";
+        maxTokens: 900
+      }
+    })) {
+      if (delta.kind === "text") text += delta.delta;
+      if (delta.kind === "tool_call") emittedToolCall = true;
+    }
+    if (emittedToolCall) return { summary: null, model, cacheReuseExpected };
+    if (!text.trim()) return { summary: null, model, cacheReuseExpected };
+    return { summary: text.trim(), model, cacheReuseExpected };
   } catch {
-    return null;
+    return { summary: null, model, cacheReuseExpected };
   } finally {
     clearTimeout(timeout);
     input.signal?.removeEventListener("abort", onOuterAbort);
   }
 }
-async function resolveCompactProviderConfig() {
-  const active = getProviderConfig().activeProviderId;
-  const meta3 = await resolveApiKeyWithMeta(active);
-  const apiKey = meta3?.apiKey;
-  if (!apiKey) return null;
-  const custom2 = getCustomEndpoint(active);
-  let baseUrl = custom2 || (active === "openai-compatible" || active === "custom" ? process.env.OPENAI_BASE_URL ?? PROVIDER_ENDPOINTS[active] : PROVIDER_ENDPOINTS[active]);
-  if (!baseUrl) return null;
-  const model = getModelForProvider(active);
-  return {
-    apiKey,
-    baseUrl,
-    model,
-    providerId: active
-  };
-}
-var COMPACT_SYSTEM;
+var COMPACTION_INSTRUCTION, REPLAY_TIMEOUT_MS;
 var init_llmCompact = __esm({
   "src/cli/budget/llmCompact.ts"() {
     "use strict";
-    init_providerConfig();
-    init_keyStore();
-    init_openai_compatible();
-    COMPACT_SYSTEM = `You compress earlier turns of a coding-agent session into a dense continuity brief.
-Output plain text (no markdown fences) with these sections:
-1) Goal \u2014 what the user wants
-2) Decisions \u2014 choices already made
-3) Done \u2014 completed work / files changed
-4) Open \u2014 remaining tasks / blockers
-5) Constraints \u2014 important rules the agent must keep
+    COMPACTION_INSTRUCTION = `
+You are now acting as a compaction engine for this coding-agent session.
 
-Be factual and concise. Max ~400 words. Do not invent work that was not present.`;
+Condense the conversation ABOVE into a compact checkpoint sufficient to continue the task.
+
+Preserve:
+- user's goal and evolving intent
+- decisions already made
+- exact file paths and identifiers
+- code changes already completed
+- commands/errors that still matter
+- constraints
+- unfinished work
+- the single most likely next action
+
+Do not call tools.
+Do not mention this summarization request.
+Output only the checkpoint.
+Be concise.
+`.trim();
+    REPLAY_TIMEOUT_MS = 6e4;
   }
 });
 
@@ -34472,6 +34718,7 @@ function resolveMaxMessages(opts) {
     turns = Math.min(turns, 3);
   }
   if (turns <= 0) return 0;
+  if (opts?.force && opts?.maxMessages) return Math.max(1, opts.maxMessages);
   return turns * 4;
 }
 function findValidCutIndex(messages, naiveCut) {
@@ -34537,12 +34784,18 @@ function pruneToolResultsDetailed(messages, opts) {
 function compactHistory(messages, opts) {
   return compactHistoryDetailed(messages, opts).messages;
 }
+function buildCheckpointMessage(summaryText) {
+  return {
+    role: "user",
+    content: CHECKPOINT_WRAPPER_PREFIX + "\n\n<compacted-summary>\n" + summaryText + "\n</compacted-summary>"
+  };
+}
 function compactHistoryDetailed(messages, opts) {
   const maxMessages = resolveMaxMessages(opts);
   if (maxMessages === 0) {
     return { messages: [], compacted: true, messagesRemoved: messages.length, summary: "" };
   }
-  if (messages.length <= maxMessages * 2) {
+  if (messages.length <= maxMessages * 2 && !opts?.force) {
     return {
       messages,
       compacted: false,
@@ -34550,7 +34803,7 @@ function compactHistoryDetailed(messages, opts) {
       summary: ""
     };
   }
-  const naiveCut = messages.length - maxMessages;
+  const naiveCut = Math.max(0, messages.length - maxMessages);
   const cut = findValidCutIndex(messages, naiveCut);
   if (cut === 0) {
     return {
@@ -34564,10 +34817,9 @@ function compactHistoryDetailed(messages, opts) {
   const pruned = pruneToolResultsDetailed(messages.slice(cut));
   const kept = pruned.messages;
   const summaryText = extractiveHistorySummary(droppedMsgs);
-  const summary = {
-    role: "system",
-    content: summaryText || `${COMPACT_MARKER} ${cut} earlier message(s) dropped.`
-  };
+  const summary = buildCheckpointMessage(
+    summaryText || `${COMPACT_MARKER} ${cut} earlier message(s) dropped.`
+  );
   return {
     messages: [summary, ...kept],
     compacted: true,
@@ -34582,29 +34834,58 @@ async function compactHistoryAsync(messages, opts) {
   const cut = base.messagesRemoved;
   const droppedMsgs = messages.slice(0, cut);
   const extractive = extractiveHistorySummary(droppedMsgs);
-  const droppedTranscript = formatDroppedForLlm(droppedMsgs);
   let summaryText = extractive;
-  try {
-    const llm = await llmSummarizeHistory({
-      extractive,
-      droppedTranscript,
-      signal: opts?.signal
-    });
-    if (llm && llm.trim().length > 40) summaryText = llm.trim();
-  } catch {
+  let cacheReuseExpected;
+  let replayExactPrefix;
+  const canReplay = !!(opts?.providerStream && opts?.requestSnapshot);
+  if (canReplay) {
+    try {
+      const replay = await llmSummarizeHistoryReplay({
+        providerStream: opts.providerStream,
+        provider: opts.requestSnapshot.provider,
+        model: opts.requestSnapshot.model,
+        systemMessages: opts.requestSnapshot.systemMessages,
+        tools: opts.requestSnapshot.tools,
+        droppedMessages: droppedMsgs,
+        signal: opts?.signal
+      });
+      cacheReuseExpected = replay.cacheReuseExpected;
+      if (replay.summary && replay.summary.trim().length > 40) {
+        const sourceTokens = roughTokens(droppedMsgs);
+        const summaryTok = Math.ceil(replay.summary.length / 4);
+        if (summaryTok < sourceTokens) {
+          summaryText = replay.summary.trim();
+        }
+      }
+    } catch {
+    }
   }
   const pruned = pruneToolResultsDetailed(messages.slice(cut));
   const kept = pruned.messages;
-  const summary = { role: "system", content: summaryText };
+  const summary = buildCheckpointMessage(summaryText);
   return {
     messages: [summary, ...kept],
     compacted: true,
     messagesRemoved: cut,
     summary: summaryText,
-    prunedToolResults: pruned.stats.pruned
+    prunedToolResults: pruned.stats.pruned,
+    cacheReuseExpected,
+    replayExactPrefix
   };
 }
-var COMPACT_MARKER;
+function roughTokens(msgs) {
+  let n = 0;
+  for (const m of msgs) {
+    n += Math.ceil((m.content ?? "").length / 4);
+    if (m.toolCalls) {
+      for (const tc of m.toolCalls) {
+        n += Math.ceil(JSON.stringify(tc.args ?? {}).length / 4);
+      }
+    }
+  }
+  return Math.max(1, n);
+}
+var COMPACT_MARKER, CHECKPOINT_WRAPPER_PREFIX;
 var init_historyCompaction = __esm({
   "src/cli/hooks/historyCompaction.ts"() {
     "use strict";
@@ -34612,6 +34893,30 @@ var init_historyCompaction = __esm({
     init_llmCompact();
     init_envNumber();
     COMPACT_MARKER = "[history] Earlier turns were compacted to stay within the context budget.";
+    CHECKPOINT_WRAPPER_PREFIX = "This is an automatically generated checkpoint of earlier conversation. Treat it as established context and continue directly.";
+  }
+});
+
+// src/cli/budget/requestSnapshotStore.ts
+function recordRequestSnapshot(sessionId, snapshot) {
+  store3.set(sessionId, { snapshot });
+}
+function recordRequestUsage(sessionId, usage) {
+  const entry = store3.get(sessionId);
+  if (!entry) return;
+  entry.usage = usage;
+}
+function getRequestSnapshotWithUsage(sessionId) {
+  return store3.get(sessionId) ?? null;
+}
+function clearAllRequestSnapshots() {
+  store3.clear();
+}
+var store3;
+var init_requestSnapshotStore = __esm({
+  "src/cli/budget/requestSnapshotStore.ts"() {
+    "use strict";
+    store3 = /* @__PURE__ */ new Map();
   }
 });
 
@@ -34656,6 +34961,7 @@ function appendMessages(msgs) {
 function clearHistory() {
   history = [];
   lastClarification = null;
+  clearAllRequestSnapshots();
   clearSessionTodos();
   clearSessionPermissionGrants();
 }
@@ -34814,6 +35120,7 @@ var init_conversationContext = __esm({
     init_toolPermissions();
     init_sessionTodos();
     init_historyCompaction();
+    init_requestSnapshotStore();
     history = [];
     lastClarification = null;
     SHORT_CONTINUE = /^(procedi|continua|continue|go\s*ahead|go|ok|okay|sì|si|yes|vai|avanti|next|proceed|conferma|confermo|applica|fai|scrivi|esegui|implementa|vai pure|fai pure|ok procedi|sì procedi|si procedi)$/i;
@@ -35212,7 +35519,7 @@ import {
 } from "node:fs";
 import { join as join18, basename } from "node:path";
 import { homedir as homedir9 } from "node:os";
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 function resolveWorkspaceRoot(projectRoot = process.cwd()) {
   const candidates = [
     join18(projectRoot, ".zelari"),
@@ -35228,7 +35535,7 @@ function resolveWorkspaceRoot(projectRoot = process.cwd()) {
   return candidates[0];
 }
 function hashProject(projectPath) {
-  return createHash6("sha1").update(realpathSync(projectPath)).digest("hex").slice(0, 12);
+  return createHash7("sha1").update(realpathSync(projectPath)).digest("hex").slice(0, 12);
 }
 function isWritableDir(dir) {
   try {
@@ -35819,8 +36126,8 @@ async function loadDurableContext(projectRoot, opts) {
     return cache.text;
   }
   try {
-    const store3 = await getStateStore(projectRoot, env);
-    const text = await store3.materializeContext(void 0, opts?.maxChars);
+    const store4 = await getStateStore(projectRoot, env);
+    const text = await store4.materializeContext(void 0, opts?.maxChars);
     cache = { text: text || "", at: now, projectRoot };
     return cache.text;
   } catch {
@@ -37740,7 +38047,7 @@ __export(agentsMd_exports, {
   updateAgentsMd: () => updateAgentsMd
 });
 import { existsSync as existsSync32, readFileSync as readFileSync28, writeFileSync as writeFileSync18 } from "node:fs";
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 import { join as join27 } from "node:path";
 import { readFile as readFile3 } from "node:fs/promises";
 async function readPackageJson2(projectRoot) {
@@ -37955,7 +38262,7 @@ async function updateAgentsMd(ctx, projectRoot) {
   return { changed: true, sections: changedSections };
 }
 function hash2(s) {
-  return createHash7("sha256").update(s).digest("hex").slice(0, 16);
+  return createHash8("sha256").update(s).digest("hex").slice(0, 16);
 }
 var AUTO_SECTIONS, MARKER_OPEN, MARKER_CLOSE, GENERATORS;
 var init_agentsMd = __esm({
@@ -38766,7 +39073,7 @@ __export(commitHelpers_exports, {
 });
 async function tryStateCommit(args) {
   try {
-    const store3 = args.store ?? await getStateStore(args.projectRoot, args.env);
+    const store4 = args.store ?? await getStateStore(args.projectRoot, args.env);
     let workspaceCheckpointId = args.workspaceCheckpointId;
     if (!workspaceCheckpointId && args.withCheckpoint && (args.env ?? process.env).ZELARI_CHECKPOINT !== "0") {
       const cp = await createCheckpoint(
@@ -38775,7 +39082,7 @@ async function tryStateCommit(args) {
       );
       if (cp.ok) workspaceCheckpointId = cp.value.id;
     }
-    const meta3 = await store3.commit({
+    const meta3 = await store4.commit({
       mode: args.mode,
       label: args.label,
       layer: args.layer,
@@ -42783,9 +43090,9 @@ var init_oauthDesktop = __esm({
     init_chatgptOAuth();
     init_anthropicOAuth();
     DEFAULT_MODELS = {
-      grok: "grok-4.5",
-      chatgpt: "gpt-5.2-codex",
-      anthropic: "claude-sonnet-4-5"
+      grok: "grok-4.6",
+      chatgpt: "gpt-5.6-codex",
+      anthropic: "claude-sonnet-4-6"
     };
   }
 });
@@ -43045,12 +43352,12 @@ function handleModelSet(ctx, model) {
 }
 function handleEffortShow(ctx) {
   const id = ctx.activeProviderSpec.id;
-  const cap3 = thinkingCapabilityFor(id);
+  const cap3 = thinkingCapabilityFor(id, ctx.activeModel);
   const current = stringifyThinkingSpec(getThinkingForProvider(id));
   const options = [
     "auto",
     "off",
-    ...cap3.effort ? ["low", "medium", "high"] : [],
+    ...cap3.efforts ?? (cap3.effort ? ["low", "medium", "high"] : []),
     ...cap3.budget ? ["budget:<tokens>"] : []
   ];
   appendSystem(
@@ -43063,7 +43370,7 @@ function handleEffortSet(ctx, raw) {
   if (!isValidThinkingInput(raw)) {
     appendSystem(
       ctx.setMessages,
-      `[effort] invalid spec "${raw}" \u2014 use auto | off | low | medium | high | budget:<tokens>`
+      `[effort] invalid spec "${raw}" \u2014 use auto | off | low | medium | high | xhigh | max | budget:<tokens>`
     );
     return;
   }
@@ -43624,6 +43931,11 @@ function buildDesktopConfigSnapshot() {
   const providers = PROVIDERS.map((p3) => {
     const cached2 = getCachedModels(p3.id);
     const models = cached2?.models.map((m) => m.id) ?? [];
+    if (models.length === 0) {
+      for (const m of getStaticFallbackModels(p3.id)) {
+        if (!models.includes(m.id)) models.push(m.id);
+      }
+    }
     const defaultModel = config2.modelByProvider[p3.id] ?? "";
     if (defaultModel && !models.includes(defaultModel)) {
       models.unshift(defaultModel);
@@ -43647,7 +43959,7 @@ function buildDesktopConfigSnapshot() {
       hasRefreshToken: Boolean(stored?.refreshToken),
       oauthSupported: isOAuthProvider(p3.id),
       thinking: config2.thinkingByProvider[p3.id] ?? "auto",
-      thinkingCapability: thinkingCapabilityFor(p3.id)
+      thinkingCapability: thinkingCapabilityFor(p3.id, defaultModel)
     };
   });
   return {
@@ -44319,7 +44631,7 @@ import {
 } from "node:fs";
 import { join as join36 } from "node:path";
 import { homedir as homedir13 } from "node:os";
-import { createHash as createHash8, randomBytes as randomBytes5, timingSafeEqual } from "node:crypto";
+import { createHash as createHash9, randomBytes as randomBytes5, timingSafeEqual } from "node:crypto";
 function getZelariHome() {
   return join36(homedir13(), ".zelari-code");
 }
@@ -44395,8 +44707,8 @@ function loadOrCreateToken(explicit) {
 }
 function tokenMatches(expected, provided) {
   if (!provided) return false;
-  const a = createHash8("sha256").update(expected).digest();
-  const b = createHash8("sha256").update(provided).digest();
+  const a = createHash9("sha256").update(expected).digest();
+  const b = createHash9("sha256").update(provided).digest();
   try {
     return timingSafeEqual(a, b);
   } catch {
@@ -49063,34 +49375,58 @@ function phaseKnobs(phase2) {
     })
   };
 }
-function occupancyOf(hist, sessionExtra, contextLimit) {
-  const estimated = estimateHistoryTokens(hist);
-  const occupancy = Math.min(1, (estimated + sessionExtra) / contextLimit);
-  return { estimated, occupancy };
-}
+var RESERVED_OUTPUT_TOKENS = 8192;
 async function applyBudgetPolicyAsync(history2, phase2, opts) {
   const contextLimit = resolveContextLimit(opts?.model);
   const sessionExtra = opts?.sessionTokens ?? 0;
   const warnings = [];
   let { historyTurns, maxToolLoopIterations } = phaseKnobs(phase2);
+  const envelope = opts?.requestSnapshot ?? null;
+  const replayBase = envelope ? {
+    provider: envelope.snapshot.provider,
+    model: envelope.snapshot.model,
+    systemMessages: envelope.snapshot.systemMessages,
+    tools: envelope.snapshot.tools
+  } : opts?.providerStream ? { provider: "local", model: opts?.model ?? "unknown", systemMessages: [], tools: [] } : null;
+  const headerTokens = envelope ? estimateSystemTokensLite(envelope.snapshot.systemMessages) + estimateToolSchemaTokensLite(envelope.snapshot.tools) : 0;
+  const convTokensOf = (h) => estimateConversationTokensLite(h);
   let hist = history2;
-  let { estimated, occupancy } = occupancyOf(hist, sessionExtra, contextLimit);
+  let estimated = envelope ? headerTokens + convTokensOf(hist) + RESERVED_OUTPUT_TOKENS : estimateHistoryTokens(hist) + sessionExtra;
+  let occupancy = Math.min(1, estimated / contextLimit);
   let compactSummary = "";
   let messagesRemoved = 0;
+  let cacheReuseExpected;
+  let prunedTotal = 0;
   if (occupancy >= 0.7 && occupancy < 0.85) {
     warnings.push(
-      `[budget] context ~${Math.round(occupancy * 100)}% full (${estimated + sessionExtra}/${contextLimit} tok est.) \u2014 consider /compact or shorter replies.`
+      `[budget] context ~${Math.round(occupancy * 100)}% full (${estimated}/${contextLimit} tok full-request est.) \u2014 consider /compact or shorter replies.`
     );
   }
+  if (occupancy >= 0.8) {
+    const pruned = pruneToolResultsDetailed(hist);
+    if (pruned.stats.pruned > 0) {
+      hist = pruned.messages;
+      prunedTotal += pruned.stats.pruned;
+      estimated = envelope ? headerTokens + convTokensOf(hist) + RESERVED_OUTPUT_TOKENS : estimateHistoryTokens(hist) + sessionExtra;
+      occupancy = Math.min(1, estimated / contextLimit);
+      warnings.push(
+        `[budget] pruned ${pruned.stats.pruned} oversized tool result(s) \u2192 ${Math.round(occupancy * 100)}% (${estimated} tok).`
+      );
+    }
+  }
   const fold = (r, label, forcedTurns) => {
     hist = r.messages;
     if (r.compacted) {
       messagesRemoved += r.messagesRemoved;
       if (r.summary) compactSummary = r.summary;
+      if (r.cacheReuseExpected !== void 0) {
+        cacheReuseExpected = r.cacheReuseExpected;
+      }
     }
-    ({ estimated, occupancy } = occupancyOf(hist, sessionExtra, contextLimit));
+    estimated = envelope ? headerTokens + convTokensOf(hist) + RESERVED_OUTPUT_TOKENS : estimateHistoryTokens(hist) + sessionExtra;
+    occupancy = Math.min(1, estimated / contextLimit);
     warnings.push(
-      `[budget] ${label} at ${forcedTurns === 2 ? "95%" : "85%"} \u2014 kept ~${forcedTurns} turns (${estimated} tok history est.` + (r.messagesRemoved ? `, removed ${r.messagesRemoved} msgs` : "") + `).`
+      `[budget] ${label} \u2014 kept ~${forcedTurns} turns (${estimated} tok est.` + (r.messagesRemoved ? `, removed ${r.messagesRemoved} msgs` : "") + (r.cacheReuseExpected === false ? ", cache reuse NOT expected (model override)" : "") + ")."
     );
   };
   if (occupancy >= 0.85) {
@@ -49100,39 +49436,91 @@ async function applyBudgetPolicyAsync(history2, phase2, opts) {
       maxToolLoopIterations,
       phase2 === "plan" ? 24 : 40
     );
-    const r = await compactHistoryAsync(hist, {
-      maxMessages: forcedTurns * 4,
-      signal: opts?.signal
-    });
-    const label = r.summary.includes("\xB7 llm") ? "llm-compact" : "auto-compact";
+    let r = await compactHistoryAsync(hist, {
+      maxMessages: Math.max(2, forcedTurns * 4),
+      force: true,
+      signal: opts?.signal,
+      ...replayBase ? { requestSnapshot: replayBase, providerStream: opts?.providerStream } : {}
+    });
+    if (!r.compacted) {
+      r = await compactHistoryAsync(hist, {
+        maxMessages: 2,
+        force: true,
+        signal: opts?.signal,
+        ...replayBase ? { requestSnapshot: replayBase, providerStream: opts?.providerStream } : {}
+      });
+    }
+    const label = r.cacheReuseExpected === false ? "llm-compact (model override)" : "auto-compact";
     fold(r, label, forcedTurns);
   }
   if (occupancy >= 0.95) {
     const hard = await compactHistoryAsync(hist, {
-      maxMessages: 8,
+      maxMessages: 2,
+      force: true,
       signal: opts?.signal
     });
-    fold(hard, hard.summary.includes("\xB7 llm") ? "llm-compact" : "auto-compact", 2);
+    fold(hard, hard.summary.includes("\xB7 llm") ? "llm-compact" : "HARD trim", 2);
     historyTurns = 2;
     maxToolLoopIterations = Math.min(maxToolLoopIterations, 16);
     warnings.push(
-      `[budget] HARD context pressure (\u226595%) \u2014 prefer /clear or a new session if quality drops.`
+      "[budget] HARD context pressure (\u226595%) \u2014 prefer /clear or a new session if quality drops."
     );
   }
+  const cacheMetricsLine = envelope ? [
+    "compaction meter:",
+    `provider/model: ${envelope.snapshot.provider}/${envelope.snapshot.model}`,
+    `headerFingerprint: ${envelope.snapshot.headerFingerprint.slice(0, 12)}`,
+    `occupancy: ${Math.round(occupancy * 100)}% (${estimated}/${contextLimit})`,
+    ...envelope.usage?.cachedPromptTokens !== void 0 ? [`cachedPromptTokens: ${envelope.usage.cachedPromptTokens}`] : [],
+    ...cacheReuseExpected !== void 0 ? [`cacheReuseExpected: ${cacheReuseExpected}`] : []
+  ].join(" | ") : void 0;
   return {
     history: hist,
     warnings,
     maxToolLoopIterations,
     historyTurns,
-    estimatedHistoryTokens: estimated,
+    estimatedHistoryTokens: envelope ? convTokensOf(hist) : estimated,
     contextLimit,
     occupancy,
     compactSummary: compactSummary || void 0,
-    messagesRemoved: messagesRemoved || void 0
+    messagesRemoved: messagesRemoved || void 0,
+    ...envelope ? { contextPressureTokens: estimated } : {},
+    ...cacheReuseExpected !== void 0 ? { cacheReuseExpected } : {},
+    ...cacheMetricsLine ? { cacheMetricsLine } : {}
   };
 }
+function estimateSystemTokensLite(systemMessages) {
+  let n = 0;
+  for (const m of systemMessages) n += 4 + Math.ceil((m.content ?? "").length / 4);
+  return n;
+}
+function estimateToolSchemaTokensLite(tools) {
+  let n = 0;
+  for (const t of tools) {
+    n += Math.ceil((t.name ?? "").length / 4);
+    n += Math.ceil((t.description ?? "").length / 4);
+    n += Math.ceil(JSON.stringify(t.parameters ?? {}).length / 4);
+  }
+  return n + tools.length * 4;
+}
+function estimateConversationTokensLite(messages) {
+  let n = 0;
+  for (const m of messages) {
+    n += 4 + Math.ceil((m.content ?? "").length / 4);
+    if (m.toolCalls) {
+      for (const tc of m.toolCalls) {
+        n += Math.ceil(tc.name.length / 4) + Math.ceil(tc.id.length / 4);
+        n += Math.ceil(JSON.stringify(tc.args ?? {}).length / 4);
+      }
+    }
+    if (m.reasoningContent) n += Math.ceil(m.reasoningContent.length / 4);
+    if (m.toolCallId) n += Math.ceil(m.toolCallId.length / 4);
+  }
+  return n;
+}
 
 // src/cli/hooks/useChatTurn.ts
+init_requestSnapshotStore();
 function useChatTurn(params) {
   const {
     sessionId,
@@ -49159,17 +49547,9 @@ function useChatTurn(params) {
       let envConfig;
       let harness;
       let historySeedLen = 0;
+      let systemPrefixLen = 0;
       let turnSucceeded = false;
       try {
-        compactInPlace();
-        const budget = await applyBudgetPolicyAsync(getHistory(), getPhase(), {
-          model: getActiveModel()
-        });
-        setHistory(budget.history);
-        for (const w of budget.warnings) {
-          appendSystem(setMessages, w, Date.now());
-        }
-        historySeedLen = getHistory().length;
         const anchored = maybeAnchorShortAnswer(userText);
         const effectiveUserText = anchored ?? userText;
         const localCli = (process.env.ZELARI_LOCAL_CLI ?? "").trim();
@@ -49264,6 +49644,33 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
           });
         }
         const cwd = process.cwd();
+        const budget = await applyBudgetPolicyAsync(getHistory(), getPhase(), {
+          model: getActiveModel(),
+          sessionId,
+          // v1.36.0: envelope for full-request metering + cache-aware
+          // compaction replay (last warm prefix + provider usage anchor).
+          requestSnapshot: getRequestSnapshotWithUsage(sessionId),
+          providerStream
+        });
+        setHistory(budget.history);
+        for (const w of budget.warnings) {
+          appendSystem(setMessages, w, Date.now());
+        }
+        if ((budget.messagesRemoved ?? 0) > 0) {
+          const envelope = getRequestSnapshotWithUsage(sessionId);
+          const compactionEvent = createBrainEvent("session_compacted", sessionId, {
+            summary: budget.compactSummary ?? "",
+            messagesRemoved: budget.messagesRemoved ?? 0,
+            ...envelope ? {
+              sourceRequestFingerprint: envelope.snapshot.requestFingerprint,
+              headerFingerprint: envelope.snapshot.headerFingerprint
+            } : {},
+            ...budget.contextPressureTokens !== void 0 ? { sourceEstimatedTokens: budget.contextPressureTokens } : {},
+            ...budget.cacheReuseExpected !== void 0 ? { cacheReuseExpected: budget.cacheReuseExpected } : {}
+          });
+          void writerRef.current?.append(compactionEvent);
+        }
+        historySeedLen = getHistory().length;
         let composedWorkspace = "";
         let composedInstructions = "";
         let hasPlan = false;
@@ -49421,6 +49828,7 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
           lastStableHash = hashStablePrompt(fallback);
           systemMessages = [{ role: "system", content: fallback }];
         }
+        systemPrefixLen = systemMessages.length;
         const maxToolCallsPerTurn = envNumber(process.env.ZELARI_MAX_TOOL_CALLS, {
           default: 25,
           min: 1
@@ -49433,7 +49841,10 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
         });
         const harness2 = new AgentHarness({
           model: envConfig.model,
-          provider: "openai-compatible",
+          // v1.36.0 (P0.2): real provider identity — the harness used to
+          // hardcode "openai-compatible" (the transport family) so snapshots
+          // and telemetry mislabeled deepseek/glm/minimax routing.
+          provider: envConfig.providerId,
           messages: [
             ...systemMessages,
             // v1.8.0: shared rolling history (agent/council/zelari) so short
@@ -49452,6 +49863,9 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
           cwd,
           maxToolCallsPerTurn,
           maxToolLoopIterations,
+          // v1.36.0: routed-request snapshots feed the meter (occupancy) and
+          // the cache-aware compaction replay (last warm prefix).
+          onRequestSnapshot: (snap) => recordRequestSnapshot(sessionId, snap),
           ...maxToolLoopHardCap > 0 ? { maxToolLoopHardCap } : {}
         });
         harnessRef.current = harness2;
@@ -49466,6 +49880,14 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
           for await (const event of harness2.run()) {
             if (event.type === "message_end") {
               if (event.usage) realUsage = event.usage;
+              if (event.usage) {
+                recordRequestUsage(sessionId, {
+                  promptTokens: event.usage.promptTokens,
+                  completionTokens: event.usage.completionTokens,
+                  totalTokens: event.usage.totalTokens,
+                  cachedPromptTokens: event.usage.cachedPromptTokens
+                });
+              }
               if (streamContent) {
                 const sealed = streamScrub.finalize(streamContent);
                 if (useLiveModel) setStreaming(commitStreaming, sealed, event.ts);
@@ -49625,18 +50047,17 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
             const h = harnessRef.current;
             if (h && turnSucceeded) {
               const all = h.getMessages();
-              const seedLen = 1 + historySeedLen + 1;
+              const seedLen = systemPrefixLen + historySeedLen + 1;
               if (all.length > seedLen) {
                 appendMessages(
-                  all.slice(seedLen).map(
-                    (m) => m.role === "assistant" && m.content ? {
-                      ...m,
-                      content: cleanAgentContent(m.content, {
-                        stripQuestion: false,
-                        stripThink: false
-                      })
-                    } : m
-                  )
+                  all.slice(seedLen).map((m) => {
+                    if (m.role !== "assistant" || !m.content) return m;
+                    const cleaned = cleanAgentContent(m.content, {
+                      stripQuestion: false,
+                      stripThink: false
+                    });
+                    return cleaned === m.content ? m : { ...m, content: cleaned };
+                  })
                 );
               }
             }
@@ -51579,12 +52000,12 @@ init_fileStateStore();
 async function restoreDurableState(opts) {
   const restoreTree = opts.restoreTree !== false;
   try {
-    const store3 = opts.store ?? await getStateStore(opts.projectRoot);
+    const store4 = opts.store ?? await getStateStore(opts.projectRoot);
     let meta3;
     if (opts.commitId) {
-      meta3 = await store3.setHead(opts.commitId);
+      meta3 = await store4.setHead(opts.commitId);
     } else {
-      meta3 = await store3.head();
+      meta3 = await store4.head();
       if (!meta3) {
         return {
           ok: false,
@@ -51637,8 +52058,8 @@ function ago2(ms) {
   return `${Math.round(s / 3600)}h ago`;
 }
 async function handleStateStatus(ctx) {
-  const store3 = await getStateStore(ctx.cwd);
-  const head = await store3.head();
+  const store4 = await getStateStore(ctx.cwd);
+  const head = await store4.head();
   if (!head) {
     appendSystem(
       ctx.setMessages,
@@ -51646,9 +52067,9 @@ async function handleStateStatus(ctx) {
     );
     return;
   }
-  const discoveries = await store3.loadDiscoveries(head.id);
+  const discoveries = await store4.loadDiscoveries(head.id);
   const reusable = discoveries.filter((d) => d.reusable).length;
-  const recent = await store3.list(8);
+  const recent = await store4.list(8);
   const lines = recent.map((c, i) => {
     const ver2 = c.verification.ran ? c.verification.ok ? "ok" : "fail" : "n/a";
     return `  ${i === 0 ? "\u2192" : " "} ${c.id}  ${ago2(c.createdAt)}  ${c.label}  ver=${ver2}` + (c.layer ? `  [${c.layer}]` : "") + (c.stablePromptHash ? `  hash=${c.stablePromptHash.slice(0, 8)}` : "");
@@ -51667,9 +52088,9 @@ async function handleStateStatus(ctx) {
   );
 }
 async function handleStateCommit(ctx, label) {
-  const store3 = await getStateStore(ctx.cwd);
+  const store4 = await getStateStore(ctx.cwd);
   try {
-    const meta3 = await store3.commit({
+    const meta3 = await store4.commit({
       mode: "agent",
       label: label?.trim() || "manual state commit",
       layer: "manual",
@@ -51696,8 +52117,8 @@ async function handleStateCommit(ctx, label) {
   }
 }
 async function handleStateShow(ctx, id) {
-  const store3 = await getStateStore(ctx.cwd);
-  const meta3 = id ? await store3.get(id) : await store3.head();
+  const store4 = await getStateStore(ctx.cwd);
+  const meta3 = id ? await store4.get(id) : await store4.head();
   if (!meta3) {
     appendSystem(
       ctx.setMessages,
@@ -51705,7 +52126,7 @@ async function handleStateShow(ctx, id) {
     );
     return;
   }
-  const text = await store3.materializeContext(meta3.id, 6e3);
+  const text = await store4.materializeContext(meta3.id, 6e3);
   appendSystem(ctx.setMessages, `[state] show ${meta3.id}
 ${text}`);
 }
@@ -53214,14 +53635,14 @@ async function handleSkillCompare(ctx, ids, fallbackMessage) {
 }
 function handleCouncilFeedback(ctx, memberId, score, note) {
   try {
-    const store3 = new FeedbackStore();
-    const entry = store3.record({
+    const store4 = new FeedbackStore();
+    const entry = store4.record({
       memberId,
       score,
       ...note ? { note } : {},
       ...ctx.sessionId ? { sessionId: ctx.sessionId } : {}
     });
-    const stats = store3.getStats(memberId);
+    const stats = store4.getStats(memberId);
     appendSystem(
       ctx.setMessages,
       `[council-feedback] ${memberId} rated ${entry.score}/5 \u2014 running avg ${stats.avg.toFixed(2)} over ${stats.count} rating(s).`