chainlesschain 0.166.97 → 0.166.99

package/src/lib/model-capabilities.js

@@ -98,15 +98,17 @@ export function resolveAgentOutputBudget({
     const effectiveModel = model || "claude-sonnet-4-6";
     const { maxTokens } = mergeProviderOptions("anthropic", effectiveModel);
     const defaultCap = maxTokens || 8192;
+    const explicitCap =
+      effectiveModel === "claude-haiku-5-5" ? 128000 : defaultCap;
     const requestMaxOutputTokens =
-      requested === null ? defaultCap : Math.min(defaultCap, requested);
+      requested === null ? defaultCap : Math.min(explicitCap, requested);
     return Object.freeze({
       requestMaxOutputTokens,
       plannedOutputReserveTokens: requestMaxOutputTokens,
       outputReserveSource:
         requested === null
           ? "anthropic-request-default"
-          : requested > defaultCap
+          : requested > explicitCap
             ? "anthropic-request-clamp"
             : "explicit-request-cap",
     });
@@ -271,6 +273,12 @@ export function resolveModelCapabilityProfile({
     runtimeVerified: false,
     ...output,
     advertisedMaxOutputTokens: documented?.advertisedMaxOutputTokens ?? null,
+    ...(documented?.adaptiveThinkingDefault
+      ? {
+          adaptiveThinkingDefault: true,
+          defaultReasoningEffort: documented.defaultReasoningEffort,
+        }
+      : {}),
     ...(documented?.reasoningEfforts
       ? { reasoningEfforts: [...documented.reasoningEfforts] }
       : {}),

package/src/lib/model-catalog-review.js

@@ -92,6 +92,7 @@ export function reviewModelCatalog(review, snapshots = {}) {
     for (const field of [
       "cacheReadMultiplier",
       "cacheWriteMultiplier",
+      "cacheWrite1hMultiplier",
       "longContext",
       "serviceMultipliers",
     ]) {

package/src/lib/model-context-catalog.js

@@ -144,13 +144,38 @@ export const DOCUMENTED_OPENAI_MODELS = Object.freeze({
 });
 
 export const DOCUMENTED_ANTHROPIC_MODELS = Object.freeze({
+  "claude-haiku-5-5": Object.freeze({
+    contextWindowTokens: 1000000,
+    advertisedMaxOutputTokens: 128000,
+    reasoningEfforts: Object.freeze(["low", "medium", "high", "xhigh", "max"]),
+    defaultReasoningEffort: "medium",
+    adaptiveThinkingDefault: true,
+    pricing: Object.freeze({ in: 0.1, out: 0.5 }),
+    pricingTerms: Object.freeze({
+      cacheReadMultiplier: 0.1,
+      cacheWriteMultiplier: 1.25,
+      cacheWrite1hMultiplier: 2,
+      longContext: Object.freeze({
+        threshold: 100000,
+        inputMultiplier: 5,
+        outputMultiplier: 5,
+      }),
+      serviceMultipliers: Object.freeze({ standard: 1, default: 1 }),
+    }),
+    sources: Object.freeze([
+      "https://platform.claude.com/docs/en/models/haiku-5-5/overview",
+      "https://platform.claude.com/docs/en/models/haiku-5-5/migration-guide",
+      "https://platform.claude.com/docs/en/about-claude/pricing",
+    ]),
+  }),
   "claude-sonnet-5-5": Object.freeze({
     contextWindowTokens: 1000000,
     advertisedMaxOutputTokens: null,
     pricing: Object.freeze({ in: 2, out: 10 }),
-    pricingTerms: Object.freeze({ cacheReadMultiplier: 0.1 }),
+    pricingTerms: Object.freeze({ cacheReadMultiplier: 0.05 }),
     sources: Object.freeze([
       "https://code.claude.com/docs/en/changelog#2-1-284",
+      "https://platform.claude.com/docs/en/about-claude/pricing",
     ]),
   }),
   "claude-opus-5-5": Object.freeze({

package/src/lib/provider-http-error.js

@@ -3,9 +3,14 @@
  * Keep structured provider diagnostics while redacting credential-shaped text.
  */
 
-function safePart(value) {
+function safePart(value, secrets = []) {
   if (value == null) return "";
-  return String(value)
+  let text = String(value);
+  for (const secret of secrets) {
+    if (typeof secret === "string" && secret)
+      text = text.replaceAll(secret, "***");
+  }
+  return text
     .replace(/\s+/g, " ")
     .replace(/\b(Bearer\s+)[A-Za-z0-9._~+/-]+=*\b/gi, "$1***")
     .replace(/\bsk-[A-Za-z0-9_-]{8,}\b/gi, "sk-***")
@@ -13,21 +18,24 @@ function safePart(value) {
     .slice(0, 400);
 }
 
-function errorDetail(payload) {
+function errorDetail(payload, secrets) {
   if (payload == null) return { code: "", message: "" };
   const raw =
     typeof payload === "object" && payload.error != null
       ? payload.error
       : payload;
   if (typeof raw === "string") {
-    return { code: "", message: safePart(raw) };
+    return { code: "", message: safePart(raw, secrets) };
   }
   if (!raw || typeof raw !== "object") {
-    return { code: "", message: safePart(raw) };
+    return { code: "", message: safePart(raw, secrets) };
   }
   return {
-    code: safePart(raw.code || raw.type),
-    message: safePart(raw.message || raw.error_description || raw.detail),
+    code: safePart(raw.code || raw.type, secrets),
+    message: safePart(
+      raw.message || raw.error_description || raw.detail,
+      secrets,
+    ),
   };
 }
 
@@ -36,9 +44,14 @@ function errorDetail(payload) {
  * accounts and model-access denials. Preserve the safe code/message so clients
  * can show the real corrective action.
  */
-export function formatProviderHttpError(provider, status, payload = null) {
+export function formatProviderHttpError(
+  provider,
+  status,
+  payload = null,
+  { secrets = [] } = {},
+) {
   const base = `${provider} API error: HTTP ${status}`;
-  const detail = errorDetail(payload);
+  const detail = errorDetail(payload, secrets);
   const detailText = [detail.code, detail.message].filter(Boolean).join(": ");
   const detailSentence = detailText.replace(/[.!?]+$/, "");
   const classified = `${detail.code} ${detail.message}`.toLowerCase();
@@ -76,7 +89,11 @@ export function formatProviderHttpError(provider, status, payload = null) {
   return detailSentence ? `${base} — ${detailSentence}` : base;
 }
 
-export async function formatProviderResponseError(provider, response) {
+export async function formatProviderResponseError(
+  provider,
+  response,
+  { secrets = [] } = {},
+) {
   let payload = null;
   try {
     const text = await response.text();
@@ -90,5 +107,7 @@ export async function formatProviderResponseError(provider, response) {
   } catch {
     // A broken/empty body still retains the HTTP status diagnosis.
   }
-  return formatProviderHttpError(provider, response.status, payload);
+  return formatProviderHttpError(provider, response.status, payload, {
+    secrets,
+  });
 }

package/src/lib/provider-options.js

@@ -78,7 +78,11 @@ export function inferModelOverrides(modelId) {
     return { maxTokens: 16384 };
   }
 
-  // Claude Haiku — cheaper, smaller output by default.
+  if (modelId === "claude-haiku-5-5") {
+    return { maxTokens: 4096, temperature: undefined };
+  }
+
+  // Older Claude Haiku — smaller output by default.
   if (id.includes("haiku")) {
     return { maxTokens: 4096 };
   }
@@ -136,6 +140,39 @@ export function mergeProviderOptions(provider, modelId, callOverrides = {}) {
   return deepMerge(defaults, modelLayer, callOverrides || {});
 }
 
+/** Exact Haiku 5.5 request contract; null leaves older model behavior intact. */
+export function haiku55ThinkingParams(model, options = {}) {
+  if (model !== "claude-haiku-5-5") return null;
+  if (options.thinkingBudget != null) {
+    throw new TypeError(
+      "Haiku 5.5 supports adaptive thinking, not thinkingBudget",
+    );
+  }
+  const intensity = {
+    think: "medium",
+    hard: "high",
+    "think-hard": "high",
+    harder: "high",
+    ultra: "xhigh",
+    ultrathink: "xhigh",
+    true: "high",
+  };
+  const effort =
+    options.thinkingEffort ?? intensity[options.thinking] ?? "medium";
+  if (!["low", "medium", "high", "xhigh", "max"].includes(effort)) {
+    throw new TypeError(`Unsupported Haiku 5.5 reasoning effort: ${effort}`);
+  }
+  if (options.thinking === false && ["xhigh", "max"].includes(effort)) {
+    throw new TypeError(
+      "Haiku 5.5 cannot disable thinking at xhigh or max effort",
+    );
+  }
+  return {
+    thinking: { type: options.thinking === false ? "disabled" : "adaptive" },
+    output_config: { effort },
+  };
+}
+
 // =====================================================================
 // provider-options V2 governance overlay (iter27)
 // =====================================================================

package/src/lib/search-command.js

@@ -37,7 +37,10 @@ export function buildSearchCommand({
   isContent,
   platform = process.platform,
 }) {
-  const pat = String(pattern ?? "");
+  if (typeof pattern !== "string" || pattern.length === 0) {
+    return { error: "search_files requires a non-empty string pattern" };
+  }
+  const pat = pattern;
 
   if (platform === "win32") {
     // cmd.exe has no reliable way to escape an embedded double-quote, and the

package/src/lib/stream-retry.js

@@ -61,6 +61,20 @@ export function isRetryableStreamError(err, signal) {
   if (isAbortError(err)) return false;
   if (signal && signal.aborted) return false;
   if (!err) return false;
+  const msg = String(err.message || err).toLowerCase();
+  // A provider verdict stays terminal even when its detail mentions a timeout,
+  // reset or network failure. Inspect it before transport codes and wording so
+  // formatted HTTP diagnostics and failed Responses cannot trigger a replay.
+  if (
+    err.code === "CC_OPENAI_RESPONSES_FAILED" ||
+    err.cause?.code === "CC_OPENAI_RESPONSES_FAILED" ||
+    [err.status, err.statusCode, err.cause?.status, err.cause?.statusCode].some(
+      (status) => Number.isInteger(status) && status >= 400 && status <= 599,
+    ) ||
+    /\bhttp\s+[45]\d{2}\b/.test(msg)
+  ) {
+    return false;
+  }
   const code = String(err.code || err.cause?.code || "").toUpperCase();
   if (
     [
@@ -76,7 +90,6 @@ export function isRetryableStreamError(err, signal) {
   ) {
     return true;
   }
-  const msg = String(err.message || err).toLowerCase();
   return /econnreset|etimedout|econnrefused|eai_again|socket hang ?up|terminated|fetch failed|network error|timed?\s*out|premature close/.test(
     msg,
   );

package/src/lib/task-progress-tracker.js

@@ -470,6 +470,7 @@ export class TaskProgressTracker {
       guidance:
         message +
         " For an implementation task, make the smallest justified, authorized change and validate it. " +
+        "If the user requested new or updated tests, actual test changes and focused validation remain required; reading tests or passing an existing baseline does not fulfill that request. Name the concrete missing fact before another read. " +
         "For a bug fix, state the observed failure, your leading root-cause hypothesis and the smallest test that can disprove it. Run that focused reproduction or diagnostic next; use its actual output to choose the next step. Do not keep reading adjacent files without naming the specific missing fact. A timeout alone does not establish that increasing the timeout is the fix. " +
         DIAGNOSTIC_WORKFLOW_GUIDANCE +
         " " +

package/src/lib/usage-pricing-context.js

@@ -1,11 +1,52 @@
 import {
   DOCUMENTED_OPENAI_MODELS,
+  DOCUMENTED_ANTHROPIC_MODELS,
   GPT6_PRICING_TERMS,
 } from "./model-context-catalog.js";
 
+/** Keep TTL evidence distinct from the aggregate cache-write count. */
+export function projectCacheCreationUsage(usage = {}) {
+  if (usage.cacheCreationInvalid === true)
+    return { cacheCreationInvalid: true };
+  if (
+    Object.hasOwn(usage, "cache_creation_input_tokens") &&
+    Object.hasOwn(usage, "cacheCreationTokens") &&
+    usage.cache_creation_input_tokens !== usage.cacheCreationTokens
+  )
+    return { cacheCreationInvalid: true };
+  const nested = usage.cache_creation;
+  const hasFlat =
+    Object.hasOwn(usage, "cacheCreation5mTokens") ||
+    Object.hasOwn(usage, "cacheCreation1hTokens");
+  if (!Object.hasOwn(usage, "cache_creation") && !hasFlat) return {};
+  if (
+    Object.hasOwn(usage, "cache_creation") &&
+    (nested === null || typeof nested !== "object" || Array.isArray(nested))
+  )
+    return { cacheCreationInvalid: true };
+  const five = nested?.ephemeral_5m_input_tokens ?? usage.cacheCreation5mTokens;
+  const hour = nested?.ephemeral_1h_input_tokens ?? usage.cacheCreation1hTokens;
+  const total = usage.cache_creation_input_tokens ?? usage.cacheCreationTokens;
+  if (
+    ![five, hour, total].every(
+      (value) => Number.isSafeInteger(value) && value >= 0,
+    ) ||
+    five + hour !== total ||
+    (hasFlat &&
+      nested != null &&
+      (five !== usage.cacheCreation5mTokens ||
+        hour !== usage.cacheCreation1hTokens))
+  ) {
+    return { cacheCreationInvalid: true };
+  }
+  return { cacheCreation5mTokens: five, cacheCreation1hTokens: hour };
+}
+
 /** Only bounded, non-secret pricing labels may enter the durable usage ledger. */
 export function projectUsagePricingContext(usage = {}) {
-  const projected = {};
+  const projected = projectCacheCreationUsage(usage);
+  if (usage.pricingContextInvalid === true)
+    projected.pricingContextInvalid = true;
   for (const [key, alias] of [
     ["service_tier", "serviceTier"],
     ["regional_processing", "regionalProcessing"],
@@ -31,23 +72,56 @@ export function projectUsagePricingContext(usage = {}) {
       projected[key] = value;
     }
   }
+  if (Object.hasOwn(usage, "inference_geo")) {
+    const geo = usage.inference_geo;
+    if (geo !== "us" && geo !== "global") {
+      projected.inference_geo = "unknown";
+      projected.pricingContextInvalid = true;
+    } else {
+      if (
+        Object.hasOwn(projected, "regional_processing") &&
+        projected.regional_processing !== (geo === "us")
+      ) {
+        throw new TypeError(
+          "usage inference_geo conflicts with regional processing",
+        );
+      }
+      projected.inference_geo = geo;
+      projected.regional_processing = geo === "us";
+    }
+  }
   return projected;
 }
 
 /** Preserve per-request thresholds in a bounded set of aggregate price buckets. */
 export function mergeUsagePricingBucket(entry, usage) {
-  if (
-    String(entry.provider).toLowerCase() !== "openai" ||
-    !DOCUMENTED_OPENAI_MODELS[String(entry.model).toLowerCase()]?.pricing
-  )
-    return;
+  const provider = String(entry.provider).toLowerCase();
+  const model = String(entry.model).toLowerCase();
+  const terms =
+    provider === "openai" && DOCUMENTED_OPENAI_MODELS[model]?.pricing
+      ? GPT6_PRICING_TERMS
+      : provider === "anthropic"
+        ? DOCUMENTED_ANTHROPIC_MODELS[model]?.pricingTerms
+        : null;
+  if (!terms?.longContext) return;
   const metadata = projectUsagePricingContext(usage);
+  const pricingContextInvalid =
+    metadata.pricingContextInvalid === true ||
+    (provider === "anthropic" &&
+      model === "claude-haiku-5-5" &&
+      metadata.regional_processing == null);
   const promptTokens =
     usage.requestInputTokens ??
     usage.inputTokens +
       (usage.cacheReadTokens || 0) +
       (usage.cacheCreationTokens || 0);
-  const long = promptTokens > GPT6_PRICING_TERMS.longContext.threshold;
+  const long = promptTokens > terms.longContext.threshold;
+  const cache = projectCacheCreationUsage(usage);
+  const cacheEvidence = cache.cacheCreationInvalid
+    ? "invalid"
+    : cache.cacheCreation5mTokens != null
+      ? "split"
+      : "missing";
   const serviceTier = metadata.service_tier || "standard";
   const regionalProcessing = metadata.regional_processing === true;
   entry.pricingBuckets ||= [];
@@ -55,8 +129,9 @@ export function mergeUsagePricingBucket(entry, usage) {
     (item) =>
       item.serviceTier === serviceTier &&
       item.regionalProcessing === regionalProcessing &&
-      item.requestInputTokens > GPT6_PRICING_TERMS.longContext.threshold ===
-        long,
+      (item.pricingContextInvalid === true) === pricingContextInvalid &&
+      (item.cacheEvidence || "missing") === cacheEvidence &&
+      item.requestInputTokens > terms.longContext.threshold === long,
   );
   if (!bucket) {
     bucket = {
@@ -69,6 +144,18 @@ export function mergeUsagePricingBucket(entry, usage) {
       serviceTier,
       regionalProcessing,
       requestInputTokens: promptTokens,
+      ...(pricingContextInvalid ? { pricingContextInvalid: true } : {}),
+      ...(provider === "anthropic"
+        ? {
+            cacheEvidence,
+            ...(cacheEvidence === "split"
+              ? { cacheCreation5mTokens: 0, cacheCreation1hTokens: 0 }
+              : {}),
+            ...(cacheEvidence === "invalid"
+              ? { cacheCreationInvalid: true }
+              : {}),
+          }
+        : {}),
     };
     entry.pricingBuckets.push(bucket);
   }
@@ -79,8 +166,11 @@ export function mergeUsagePricingBucket(entry, usage) {
     "cacheCreationTokens",
     "totalTokens",
     "calls",
+    ...(cacheEvidence === "split"
+      ? ["cacheCreation5mTokens", "cacheCreation1hTokens"]
+      : []),
   ]) {
-    const value = usage[key] ?? (key === "calls" ? 1 : 0);
+    const value = cache[key] ?? usage[key] ?? (key === "calls" ? 1 : 0);
     if (
       !Number.isSafeInteger(value) ||
       value < 0 ||

package/src/runtime/agent-core.js

@@ -15,6 +15,7 @@
  */
 
 import fs from "fs";
+import { isUtf8 } from "node:buffer";
 import {
   _isNonNegativeSafeInteger,
   _providerUsageCount,
@@ -59,6 +60,8 @@ import {
   TASK_RECOVERY_TOOLS,
 } from "../lib/task-progress-tracker.js";
 import { TOOL_RECOVERY_PAUSED_CODE } from "../lib/tool-recovery-result.js";
+import { haiku55ThinkingParams } from "../lib/provider-options.js";
+import { projectUsagePricingContext } from "../lib/usage-pricing-context.js";
 import broker from "../lib/process-execution-broker/index.js";
 import os from "os";
 import { createHash, randomUUID } from "node:crypto";
@@ -2024,6 +2027,20 @@ function applyLiteralEdit(content, oldStr, newStr, replaceAll) {
   return { count, newContent };
 }
 
+// Edits derive their output from the entire existing file. A replacement
+// decoder would silently rewrite unrelated legacy or malformed bytes.
+function readUtf8ForEdit(filePath) {
+  const bytes = fs.readFileSync(filePath);
+  if (!isUtf8(bytes)) {
+    return {
+      error: "File is not valid UTF-8; text edits require valid UTF-8 bytes.",
+      code: "CC_EDIT_INVALID_UTF8",
+    };
+  }
+  // Buffer decoding preserves a valid UTF-8 BOM and literal U+FFFD characters.
+  return { content: bytes.toString("utf8") };
+}
+
 /**
  * Compute the content an edit tool WOULD write, without writing it — the
  * left/right sides for an IDE diff review. Mirrors the corresponding
@@ -2085,7 +2102,9 @@ export function computeProposedEdit(name, args = {}, cwd = process.cwd()) {
     }
     if (name === "edit_file") {
       if (!fs.existsSync(filePath)) return null;
-      const content = fs.readFileSync(filePath, "utf8");
+      const decoded = readUtf8ForEdit(filePath);
+      if (decoded.error) return null;
+      const content = decoded.content;
       if (
         typeof args.old_string !== "string" ||
         args.old_string === "" ||
@@ -2113,7 +2132,9 @@ export function computeProposedEdit(name, args = {}, cwd = process.cwd()) {
     if (name === "edit_file_hashed") {
       if (!fs.existsSync(filePath)) return null;
       if (!args.anchor_hash || typeof args.new_line !== "string") return null;
-      const original = fs.readFileSync(filePath, "utf8");
+      const decoded = readUtf8ForEdit(filePath);
+      if (decoded.error) return null;
+      const original = decoded.content;
       const result = replaceByHash(original, {
         anchorHash: args.anchor_hash,
         expectedLine: args.expected_line,
@@ -5835,7 +5856,9 @@ async function executeToolInner(
       if (!fs.existsSync(filePath)) {
         return attachDescriptor({ error: `Notebook not found: ${filePath}` });
       }
-      const original = fs.readFileSync(filePath, "utf8");
+      const decoded = readUtf8ForEdit(filePath);
+      if (decoded.error) return attachDescriptor(decoded);
+      const original = decoded.content;
       const res = editNotebookCell(original, args);
       if (res.error) return attachDescriptor({ error: res.error });
       const wrote = writeFileVerified(filePath, res.text);
@@ -5871,7 +5894,9 @@ async function executeToolInner(
       }
       const staleEdit = _checkFileFreshness(filePath);
       if (staleEdit) return attachDescriptor({ error: staleEdit });
-      const content = fs.readFileSync(filePath, "utf8");
+      const decoded = readUtf8ForEdit(filePath);
+      if (decoded.error) return attachDescriptor(decoded);
+      const content = decoded.content;
       const replaceAll = args.replace_all === true;
       const { count, newContent } = applyLiteralEdit(
         content,
@@ -5971,7 +5996,9 @@ async function executeToolInner(
       }
       const staleHashed = _checkFileFreshness(filePath);
       if (staleHashed) return attachDescriptor({ error: staleHashed });
-      const original = fs.readFileSync(filePath, "utf8");
+      const decoded = readUtf8ForEdit(filePath);
+      if (decoded.error) return attachDescriptor(decoded);
+      const original = decoded.content;
       const result = replaceByHash(original, {
         anchorHash: args.anchor_hash,
         expectedLine: args.expected_line,
@@ -11962,10 +11989,16 @@ export async function chatWithTools(rawMessages, options) {
       messages: _toAnthropicMessages(otherMsgs),
       tools: anthropicTools,
     };
-    // Extended thinking — OPT-IN via options.thinking; off by default so the
-    // request is byte-identical to before. Model-aware (adaptive+effort on Opus
-    // 4.6+/Sonnet 4.6, legacy enabled+budget else; nothing on Haiku). temperature
-    // is never sent. RUNTIME-UNVERIFIED: no Anthropic key here to E2E the
+    if (
+      effModel.toLowerCase() === "claude-haiku-5-5" &&
+      body.messages.at(-1)?.role === "assistant"
+    ) {
+      throw new TypeError("Haiku 5.5 does not support assistant prefill.");
+    }
+    // Legacy models retain opt-in thinking. Exact Haiku 5.5 uses its documented
+    // adaptive/medium default and accepts an explicit disabled setting.
+    // Sampling parameters are never sent. RUNTIME-UNVERIFIED: no Anthropic key
+    // here to E2E the
     // thinking-block signature replay (see cli_claude_code_parity_landed memory).
     const thinkingParams = _anthropicThinkingParams(
       effModel,
@@ -12046,6 +12079,11 @@ export async function chatWithTools(rawMessages, options) {
     const data = await response.json();
     const normalized = _normalizeAnthropicResponse(data);
     if (_hasCompleteProviderUsage(data.usage)) {
+      const cacheCreationTokens = _optionalProviderUsageCount(
+        data.usage,
+        "cache_creation_input_tokens",
+        "cache_creation_tokens",
+      );
       normalized.usage = {
         // With prompt caching, Anthropic splits input into uncached
         // `input_tokens` + cache read/write — capture all three so cost
@@ -12066,11 +12104,11 @@ export async function chatWithTools(rawMessages, options) {
           "cache_read_input_tokens",
           "cache_read_tokens",
         ),
-        cache_creation_input_tokens: _optionalProviderUsageCount(
-          data.usage,
-          "cache_creation_input_tokens",
-          "cache_creation_tokens",
-        ),
+        cache_creation_input_tokens: cacheCreationTokens,
+        ...projectUsagePricingContext({
+          ...data.usage,
+          cache_creation_input_tokens: cacheCreationTokens,
+        }),
       };
     }
     return normalized;
@@ -13067,11 +13105,12 @@ export function _openAIResponsesReasoningParams(
 
 /**
  * Decide the Anthropic `thinking` request params for a model. Returns null
- * (off) unless the caller opts in via options.thinking (true | "think" |
- * "hard" | "ultra"). Model-aware per the Claude API:
+ * (off) on legacy models unless the caller opts in via options.thinking
+ * (true | "think" | "hard" | "ultra"). Model-aware per the Claude API:
+ *   - exact Haiku 5.5 → adaptive/medium by default, explicitly disableable
  *   - Opus 4.6/4.7/4.8, Sonnet 4.6 → adaptive thinking + output_config.effort
  *   - Sonnet 4.5 / Opus 4.0-4.5 / older → legacy enabled+budget (< max_tokens)
- *   - anything else (e.g. Haiku) → null (no thinking)
+ *   - other models, including older Haiku → null (no explicit thinking)
  * temperature is never added (it 400s on Opus 4.7/4.8). Note: `xhigh`/`max`
  * effort are Opus-tier — on Sonnet they may error; left to the caller's intent.
  * RUNTIME-UNVERIFIED — no Anthropic key to validate the wire shape live.
@@ -13082,9 +13121,10 @@ export function _anthropicThinkingParams(
   options = {},
   maxTokens = 8192,
 ) {
+  const m = String(model || "").toLowerCase();
+  if (m === "claude-haiku-5-5") return haiku55ThinkingParams(m, options);
   const want = options?.thinking;
   if (!want) return null; // off by default → request unchanged
-  const m = String(model || "").toLowerCase();
   const adaptive = /opus-4-(6|7|8)/.test(m) || /sonnet-4-6/.test(m);
   const legacy =
     /sonnet-4-5/.test(m) ||
@@ -15405,6 +15445,27 @@ export async function* agentLoop(messages, options) {
       }
     }
     const contextMemoryTrustedSystemIndexes = [];
+    if (Number.isFinite(budget.limit)) {
+      // consume() already charged this dispatch. The current request may still
+      // act even when no further provider request remains. Rebuild this hint
+      // after compaction and rejection-only turns; do not persist it in history.
+      const furtherRequests = budget.remaining();
+      // Keep the stable conversation prefix ahead of this changing counter.
+      // The canonical planner protects the last conversational user bundle
+      // even when trusted ephemeral system guidance follows it.
+      callMessages = [
+        ...callMessages,
+        {
+          role: "system",
+          content:
+            `Execution budget: this request plus ${furtherRequests} further model requests. ` +
+            "For requested changes, reserve requests for implementation, focused validation, and repair or an accurate unfinished-work report. " +
+            "Reading or an existing passing baseline does not deliver requested changes. " +
+            "For research or monitoring, use the remaining requests for evidence and the requested answer; do not create files just to show activity.",
+        },
+      ];
+      contextMemoryTrustedSystemIndexes.push(callMessages.length - 1);
+    }
     if (prActionTask && !prInvestigationExhausted) {
       callMessages = [
         ...callMessages,
@@ -16299,11 +16360,27 @@ export async function* agentLoop(messages, options) {
           toolName,
           earlyAuthorityDenial,
         );
+        const preExecutionDenied =
+          earlyAuthorityDenial.code === TOOL_RECOVERY_PAUSED_CODE;
+        if (preExecutionDenied) {
+          // Declare the rejected request without an execution/ledger boundary
+          // or its arguments. Consumers can pair the refusal by provider ID.
+          yield {
+            type: "tool-pre-execution-denied",
+            tool: toolName,
+            tool_use_id: call.id,
+            turn_id: `${runId}:t${budget.consumed}`,
+            preExecutionDenied: true,
+            execution_started: false,
+          };
+        }
         yield {
           type: "tool-result",
           tool: toolName,
           result: earlyAuthorityDenial,
           error: earlyAuthorityDenial.error,
+          execution_started: false,
+          ...(preExecutionDenied ? { preExecutionDenied: true } : {}),
           tool_use_id: call.id,
           turn_id: `${runId}:t${budget.consumed}`,
           permission_decision_id: decision?.id || null,