@askalf/dario 4.8.140 → 4.8.142

package/dist/cc-template.d.ts

@@ -372,21 +372,28 @@ export declare function parseEffortSuffix(model: string): {
 /**
  * Resolve the outbound `output_config.effort` value.
  *
- * Tracks CC's wire default. Evolution:
- *   - Apr 2026, CC ~2.1.116:  effort = 'medium'   (Discussion #13 documented this)
- *   - mid-May 2026:            effort = 'high'    (dario#87 pinned to match)
- *   - May 17 2026, CC 2.1.143: effort = 'xhigh'   (verified by capture-full-body.mjs)
- *
- *   undefined → 'max' (highest *universally*-supported level. CC's own wire
- *               default is 'xhigh', but that's Opus/Fable-only — Sonnet/Haiku-class
- *               400 on 'xhigh' ("supported: high|low|max|medium"). 'max' is
- *               accepted by all and still routes to the subscription pool
- *               (verified: representative-claim=five_hour on Opus + Sonnet).
- *               Set --effort=xhigh / DARIO_EFFORT=xhigh for the Opus/Fable tier.)
- *   'low' / 'medium' / 'high' / 'xhigh' / 'max' → pin to that value
+ * Effort is a USER KNOB, not a wire constant: real CC sends whatever the
+ * user's effort setting is tuned to, and "what CC sends" in a capture is just
+ * that install's knob position. dario chased captured values for months
+ * ('medium' → 'high' → 'xhigh' across CC releases — each one somebody's
+ * setting, not a version default) and pinned the outbound effort to a fixed
+ * value, silently clamping every client's explicit choice. Since 4.8.142 the
+ * default is client-first, matching how real CC actually behaves:
+ *
+ *   undefined / 'client' → the client's `clientBody.output_config.effort`
+ *              (normalized for the wire) — forward the knob untouched.
+ *              Falls back to 'high' only when the client sent none
+ *              (OpenAI-compat clients that can't set effort).
+ *   'low' / 'medium' / 'high' / 'xhigh' / 'max' → operator pin via
+ *              --effort / DARIO_EFFORT (explicit override, wins over client)
  *   'ultracode' → 'xhigh' (CC's ultracode mode; xhigh on the wire)
- *   'client' → extract from `clientBody.output_config.effort` (normalized
- *              for the wire); fall back to the default if absent/non-string
+ *
+ * The 'high' fallback (not 'max') is dario#658 scar tissue: 'max' plus
+ * unbounded adaptive thinking exhausts max_tokens on long prompts — the
+ * stream ends `stop_reason: max_tokens` with ZERO text blocks. 'high' thinks
+ * proportionally and leaves room for the answer. A client that explicitly
+ * asks for 'max' gets 'max' — same outcome it would get talking to Anthropic
+ * directly.
  *
  * FABLE CLAMP — REMOVED 2026-07-01. Fable 5 was SUSPENDED 2026-06-12 (US-gov
  * directive) and REDEPLOYED 2026-07-01. The pre-suspension model (2026-06-09
@@ -395,12 +402,9 @@ export declare function parseEffortSuffix(model: string): {
  * through the deployed proxy (CC 2.1.198's verbatim fable body, only
  * output_config.effort mutated) shows the redeployed fable now ANSWERS all three
  * — high/xhigh/max → end_turn, zero refusals. So the clamp + the fable-only
- * default are gone: fable now takes the general path (no clamp), matching how
- * dario treats opus. The general default is `high` (see resolveEffort below) —
- * Claude Code's out-of-box default. Effort is a user-adjustable knob, so no
- * single value is "the" value; `high` is the safe unconfigured baseline.
- * `model` is retained in the signature in case a future model needs per-family
- * effort handling again.
+ * default are gone: fable takes the general path, matching how dario treats
+ * opus. `model` is retained in the signature in case a future model needs
+ * per-family effort handling again.
  *
  * Exported for tests.
  */
@@ -442,28 +446,48 @@ export type CacheControl = {
     ttl?: '5m' | '1h';
 };
 /**
- * The cache-control dario stamps on every breakpoint (2 system + tools +
- * conversation). `ttl: '1h'` mirrors real CC — dario shipped the 5-min
- * ephemeral default, so its prefix expired 12x sooner than CC's and any
- * interactive turn past the 5-min window re-created the whole prefix
- * (system + all tools) at cache-creation cost, draining the Max window far
- * faster than direct CC (root cause of dario#678). Single source of truth so
- * the emitted TTL can't silently drift back to 5m.
+ * The cache-control dario stamps on every breakpoint (2 system + 2
+ * conversation). Plain `{type:'ephemeral'}` (the 5-minute default) mirrors
+ * real CC: a loopback MITM capture of CC v2.1.203 shows no `ttl` field on any
+ * breakpoint. v4.8.140 stamped `ttl:'1h'` here on the theory that real CC
+ * used 1h — it doesn't, and 1h cache WRITES bill at 2x base input vs 1.25x
+ * for 5m, so every write in a write-heavy agentic session cost 60% more than
+ * direct CC. The dario#678 re-test caught it: the reporter's cold-start burn
+ * went +8% -> +19% on the "fixed" build. Single source of truth so the
+ * emitted shape can't drift from CC again.
  */
 export declare const CC_CACHE_CONTROL: CacheControl;
 /**
- * Place CC-style prompt-cache breakpoints on the tools array and the
- * conversation. The system prompt is already cached at build time (2 system
- * breakpoints); this adds the last tool + a single rolling breakpoint on the
- * last message — total 4, the Anthropic max, mirroring Claude Code.
- *
- * Why: dario previously cached ONLY the system prompt and stripped every
- * message breakpoint, so the tools schema (10-20KB) and the entire growing
- * conversation re-billed as FRESH input every turn. Fleet cache-read ran ~1.9%
- * vs CC's ~70-90%, draining the Max 5h/7d token window 10-50x faster — which is
- * exactly why long agentic sessions hit a wall through dario that real CC
- * sails through. CC genuinely caches tools + conversation, so NOT caching them
- * was itself a wire divergence from CC. Exported for unit testing.
+ * Place CC-style prompt-cache breakpoints on the conversation. The system
+ * prompt is already cached at build time (2 system breakpoints); this adds a
+ * rolling breakpoint on the last user message plus an anchor on the previous
+ * one — total 4, the Anthropic max.
+ *
+ * Placement mirrors a live capture of CC v2.1.203 (dario#678):
+ *
+ *  - Tools carry NO breakpoint. Real CC sends its tool array unstamped —
+ *    Anthropic renders tools -> system -> messages, so the system breakpoints
+ *    already cache the tools prefix. Stamping the last tool (pre-4.8.142) both
+ *    diverged from CC's wire shape and spent the fourth slot the conversation
+ *    anchor below needs.
+ *
+ *  - The rolling breakpoint goes on the last USER message, not the last
+ *    message. CC skips trailing role:"system" injections (agent-type updates
+ *    etc.); stamping "the last message" meant any turn ending in one wrote no
+ *    conversation entry at all, and the next request re-paid the entire
+ *    history as fresh input.
+ *
+ *  - The previous user message is anchored too. Anthropic's cache lookup
+ *    walks back at most ~20 content blocks from a breakpoint; one parallel-
+ *    tool turn (N tool_use + N tool_result blocks) can exceed that alone, and
+ *    the rolling breakpoint then can't reach the prior turn's entry — the
+ *    whole conversation re-bills at cache-WRITE cost every fan-out turn,
+ *    which is the dario#678 burn ("read every file" sessions draining the
+ *    Max window ~10x faster than direct CC). The anchor sits exactly where
+ *    the previous request's rolling breakpoint was, so the lookup hits it
+ *    positionally with no walk-back.
+ *
+ * Exported for unit testing.
  */
 export declare function applyCcPromptCaching(ccRequest: Record<string, unknown>, cacheControl: CacheControl): void;
 export declare function buildCCRequest(clientBody: Record<string, unknown>, billingTag: string, cacheControl: CacheControl, identity: {

package/dist/cc-template.js

@@ -1126,21 +1126,28 @@ function normalizeEffortForWire(effort) {
 /**
  * Resolve the outbound `output_config.effort` value.
  *
- * Tracks CC's wire default. Evolution:
- *   - Apr 2026, CC ~2.1.116:  effort = 'medium'   (Discussion #13 documented this)
- *   - mid-May 2026:            effort = 'high'    (dario#87 pinned to match)
- *   - May 17 2026, CC 2.1.143: effort = 'xhigh'   (verified by capture-full-body.mjs)
+ * Effort is a USER KNOB, not a wire constant: real CC sends whatever the
+ * user's effort setting is tuned to, and "what CC sends" in a capture is just
+ * that install's knob position. dario chased captured values for months
+ * ('medium' → 'high' → 'xhigh' across CC releases — each one somebody's
+ * setting, not a version default) and pinned the outbound effort to a fixed
+ * value, silently clamping every client's explicit choice. Since 4.8.142 the
+ * default is client-first, matching how real CC actually behaves:
  *
- *   undefined → 'max' (highest *universally*-supported level. CC's own wire
- *               default is 'xhigh', but that's Opus/Fable-only — Sonnet/Haiku-class
- *               400 on 'xhigh' ("supported: high|low|max|medium"). 'max' is
- *               accepted by all and still routes to the subscription pool
- *               (verified: representative-claim=five_hour on Opus + Sonnet).
- *               Set --effort=xhigh / DARIO_EFFORT=xhigh for the Opus/Fable tier.)
- *   'low' / 'medium' / 'high' / 'xhigh' / 'max' → pin to that value
+ *   undefined / 'client' → the client's `clientBody.output_config.effort`
+ *              (normalized for the wire) — forward the knob untouched.
+ *              Falls back to 'high' only when the client sent none
+ *              (OpenAI-compat clients that can't set effort).
+ *   'low' / 'medium' / 'high' / 'xhigh' / 'max' → operator pin via
+ *              --effort / DARIO_EFFORT (explicit override, wins over client)
  *   'ultracode' → 'xhigh' (CC's ultracode mode; xhigh on the wire)
- *   'client' → extract from `clientBody.output_config.effort` (normalized
- *              for the wire); fall back to the default if absent/non-string
+ *
+ * The 'high' fallback (not 'max') is dario#658 scar tissue: 'max' plus
+ * unbounded adaptive thinking exhausts max_tokens on long prompts — the
+ * stream ends `stop_reason: max_tokens` with ZERO text blocks. 'high' thinks
+ * proportionally and leaves room for the answer. A client that explicitly
+ * asks for 'max' gets 'max' — same outcome it would get talking to Anthropic
+ * directly.
  *
  * FABLE CLAMP — REMOVED 2026-07-01. Fable 5 was SUSPENDED 2026-06-12 (US-gov
  * directive) and REDEPLOYED 2026-07-01. The pre-suspension model (2026-06-09
@@ -1149,33 +1156,21 @@ function normalizeEffortForWire(effort) {
  * through the deployed proxy (CC 2.1.198's verbatim fable body, only
  * output_config.effort mutated) shows the redeployed fable now ANSWERS all three
  * — high/xhigh/max → end_turn, zero refusals. So the clamp + the fable-only
- * default are gone: fable now takes the general path (no clamp), matching how
- * dario treats opus. The general default is `high` (see resolveEffort below) —
- * Claude Code's out-of-box default. Effort is a user-adjustable knob, so no
- * single value is "the" value; `high` is the safe unconfigured baseline.
- * `model` is retained in the signature in case a future model needs per-family
- * effort handling again.
+ * default are gone: fable takes the general path, matching how dario treats
+ * opus. `model` is retained in the signature in case a future model needs
+ * per-family effort handling again.
  *
  * Exported for tests.
  */
 export function resolveEffort(flag, clientBody, model) {
     void model; // no per-family effort handling at present (see FABLE CLAMP note above)
-    // `high` is Claude Code's out-of-box default effort. The prior default `'max'`
-    // was the reasoning ceiling: combined with unbounded adaptive thinking it makes
-    // the model reason until it exhausts `max_tokens` — on prompts over ~5K input
-    // tokens the thinking phase consumes the entire budget, so the stream ends
-    // `stop_reason: max_tokens` with ZERO text blocks (dario#658). `high` thinks
-    // proportionally and leaves room for the answer. Effort is a user-adjustable
-    // knob; operators who want a higher tier pin it via `--effort` / DARIO_EFFORT.
-    const familyDefault = 'high';
-    if (flag === undefined)
-        return familyDefault;
-    if (flag === 'client') {
+    const fallback = 'high';
+    if (flag === undefined || flag === 'client') {
         const clientOC = clientBody.output_config;
         const clientEffort = clientOC?.effort;
         if (typeof clientEffort === 'string' && clientEffort.length > 0)
             return normalizeEffortForWire(clientEffort);
-        return familyDefault;
+        return fallback;
     }
     return normalizeEffortForWire(flag);
 }
@@ -1236,55 +1231,80 @@ export function supportsAdaptiveThinking(modelId) {
     return false;
 }
 /**
- * The cache-control dario stamps on every breakpoint (2 system + tools +
- * conversation). `ttl: '1h'` mirrors real CC — dario shipped the 5-min
- * ephemeral default, so its prefix expired 12x sooner than CC's and any
- * interactive turn past the 5-min window re-created the whole prefix
- * (system + all tools) at cache-creation cost, draining the Max window far
- * faster than direct CC (root cause of dario#678). Single source of truth so
- * the emitted TTL can't silently drift back to 5m.
+ * The cache-control dario stamps on every breakpoint (2 system + 2
+ * conversation). Plain `{type:'ephemeral'}` (the 5-minute default) mirrors
+ * real CC: a loopback MITM capture of CC v2.1.203 shows no `ttl` field on any
+ * breakpoint. v4.8.140 stamped `ttl:'1h'` here on the theory that real CC
+ * used 1h — it doesn't, and 1h cache WRITES bill at 2x base input vs 1.25x
+ * for 5m, so every write in a write-heavy agentic session cost 60% more than
+ * direct CC. The dario#678 re-test caught it: the reporter's cold-start burn
+ * went +8% -> +19% on the "fixed" build. Single source of truth so the
+ * emitted shape can't drift from CC again.
  */
-export const CC_CACHE_CONTROL = { type: 'ephemeral', ttl: '1h' };
+export const CC_CACHE_CONTROL = { type: 'ephemeral' };
 /**
- * Place CC-style prompt-cache breakpoints on the tools array and the
- * conversation. The system prompt is already cached at build time (2 system
- * breakpoints); this adds the last tool + a single rolling breakpoint on the
- * last message — total 4, the Anthropic max, mirroring Claude Code.
+ * Place CC-style prompt-cache breakpoints on the conversation. The system
+ * prompt is already cached at build time (2 system breakpoints); this adds a
+ * rolling breakpoint on the last user message plus an anchor on the previous
+ * one — total 4, the Anthropic max.
+ *
+ * Placement mirrors a live capture of CC v2.1.203 (dario#678):
+ *
+ *  - Tools carry NO breakpoint. Real CC sends its tool array unstamped —
+ *    Anthropic renders tools -> system -> messages, so the system breakpoints
+ *    already cache the tools prefix. Stamping the last tool (pre-4.8.142) both
+ *    diverged from CC's wire shape and spent the fourth slot the conversation
+ *    anchor below needs.
  *
- * Why: dario previously cached ONLY the system prompt and stripped every
- * message breakpoint, so the tools schema (10-20KB) and the entire growing
- * conversation re-billed as FRESH input every turn. Fleet cache-read ran ~1.9%
- * vs CC's ~70-90%, draining the Max 5h/7d token window 10-50x faster — which is
- * exactly why long agentic sessions hit a wall through dario that real CC
- * sails through. CC genuinely caches tools + conversation, so NOT caching them
- * was itself a wire divergence from CC. Exported for unit testing.
+ *  - The rolling breakpoint goes on the last USER message, not the last
+ *    message. CC skips trailing role:"system" injections (agent-type updates
+ *    etc.); stamping "the last message" meant any turn ending in one wrote no
+ *    conversation entry at all, and the next request re-paid the entire
+ *    history as fresh input.
+ *
+ *  - The previous user message is anchored too. Anthropic's cache lookup
+ *    walks back at most ~20 content blocks from a breakpoint; one parallel-
+ *    tool turn (N tool_use + N tool_result blocks) can exceed that alone, and
+ *    the rolling breakpoint then can't reach the prior turn's entry — the
+ *    whole conversation re-bills at cache-WRITE cost every fan-out turn,
+ *    which is the dario#678 burn ("read every file" sessions draining the
+ *    Max window ~10x faster than direct CC). The anchor sits exactly where
+ *    the previous request's rolling breakpoint was, so the lookup hits it
+ *    positionally with no walk-back.
+ *
+ * Exported for unit testing.
  */
 export function applyCcPromptCaching(ccRequest, cacheControl) {
-    // Tools — clone (CC_TOOL_DEFINITIONS is a shared module constant), strip any
-    // stray breakpoints, cache the LAST tool (caches the whole tools prefix).
+    // Tools — strip any stray client breakpoints (they'd count against the
+    // 4-breakpoint budget) without mutating shared element objects
+    // (CC_TOOL_DEFINITIONS is a module constant).
     const tools = ccRequest.tools;
     if (Array.isArray(tools) && tools.length > 0) {
-        const cloned = tools.map((t) => {
+        ccRequest.tools = tools.map((t) => {
+            if (!('cache_control' in t))
+                return t;
             const copy = { ...t };
             delete copy.cache_control;
             return copy;
         });
-        cloned[cloned.length - 1] = { ...cloned[cloned.length - 1], cache_control: cacheControl };
-        ccRequest.tools = cloned;
     }
-    // Conversation — cache up to and including the last message so the NEXT turn
-    // reads the whole prefix from cache. Client breakpoints were already stripped
-    // upstream; this is the single rolling breakpoint CC uses.
+    // Conversation — last two user messages, walking backward. Client
+    // breakpoints were already stripped upstream. Only block-array content gets
+    // a breakpoint: string content (some SDK clients) is left untouched —
+    // wrapping it would change the wire shape, and a bare string user turn is
+    // tiny anyway. Real CC / agentic sessions use block arrays, which DO cache.
     const msgs = ccRequest.messages;
     if (Array.isArray(msgs) && msgs.length > 0) {
-        const last = msgs[msgs.length - 1];
-        // Only block-array content gets a breakpoint. String content (some SDK
-        // clients) is left untouched — wrapping it would change the wire shape, and
-        // a bare string user turn is tiny anyway, so system+tools caching is the
-        // win. Real CC / agentic sessions use block arrays, which DO get cached.
-        if (Array.isArray(last.content) && last.content.length > 0) {
-            const blocks = last.content;
+        let stamped = 0;
+        for (let i = msgs.length - 1; i >= 0 && stamped < 2; i--) {
+            const msg = msgs[i];
+            if (msg.role !== 'user')
+                continue;
+            if (!Array.isArray(msg.content) || msg.content.length === 0)
+                continue;
+            const blocks = msg.content;
             blocks[blocks.length - 1] = { ...blocks[blocks.length - 1], cache_control: cacheControl };
+            stamped++;
         }
     }
 }
@@ -1557,8 +1577,8 @@ export function buildCCRequest(clientBody, billingTag, cacheControl, identity, o
     //
     // System prompt structure (3 blocks, matching real CC):
     //   [0] billing tag (no cache)
-    //   [1] agent identity (1h cache)
-    //   [2] CC's full 25KB system prompt + client's custom prompt appended (1h cache)
+    //   [1] agent identity (ephemeral cache)
+    //   [2] CC's full 25KB system prompt + client's custom prompt appended (ephemeral cache)
     // resolveSystemPrompt is the seam for --system-prompt=verbatim|partial|
     // aggressive|<file>. Default (undefined) returns CC_SYSTEM_PROMPT
     // unchanged. See docs/research/system-prompt-classifier-study.md for the empirical
@@ -1690,10 +1710,10 @@ export function buildCCRequest(clientBody, billingTag, cacheControl, identity, o
     //     — Max billing pool routing is unchanged.
     //
     // `output_config.effort` is independent of thinking and ships for all
-    // non-Haiku models that aren't opted out via skipFields. Default `'high'`
-    // matches CC 2.1.116's wire value; `--effort` flag overrides; `'client'`
-    // passes through whatever the client sent (or falls back to `'high'` if
-    // absent). See dario#87.
+    // non-Haiku models that aren't opted out via skipFields. Default: forward
+    // the client's own effort (it's a user knob — real CC wires whatever the
+    // user tuned), falling back to 'high' when the client sent none; `--effort`
+    // flag pins an operator override. See resolveEffort / dario#87.
     if (!isHaiku) {
         const skip = opts.skipFields;
         // Client-supplied thinking shape takes precedence when honorClientThinking

package/dist/cli.js

@@ -400,15 +400,17 @@ async function proxy() {
         ?? parsePositiveIntEnv(process.env['DARIO_MAX_QUEUED']);
     const queueTimeoutMs = parsePositiveIntFlag('--queue-timeout=')
         ?? parsePositiveIntEnv(process.env['DARIO_QUEUE_TIMEOUT_MS']);
-    // --effort=low|medium|high|xhigh|ultracode|max|client — override the outbound
-    // output_config.effort (dario#87). Default (unset) pins 'high' to match
-    // CC 2.1.116's wire value. 'client' passes through whatever the client
-    // sent, falling back to 'high' if the client didn't include one.
+    // --effort=low|medium|high|xhigh|ultracode|max|client — pin the outbound
+    // output_config.effort (dario#87). Default (unset) forwards the client's
+    // own effort — it's a user knob, real CC wires whatever the user tuned —
+    // falling back to 'high' when the client sent none. 'client' is a
+    // compatibility alias for the default.
     //
-    // Risk: setting effort to a non-CC-default value may cause Anthropic's
-    // classifier to flip requests to 'overage' billing. Users opting in
-    // should watch the `representative-claim` response header via -v logs
-    // and revert to default if subscription billing breaks.
+    // Risk: pinning effort overrides every client's explicit choice, and a
+    // non-CC-plausible value may cause Anthropic's classifier to flip requests
+    // to 'overage' billing. Users opting in should watch the
+    // `representative-claim` response header via -v logs and revert to default
+    // if subscription billing breaks.
     const effort = resolveEffortFlag(args, process.env['DARIO_EFFORT']);
     // --max-tokens=<N|client> — override outbound max_tokens (dario#88,
     // Hermes compat). Default unset pins 32000 (CC 2.1.116's wire default).
@@ -1321,17 +1323,19 @@ async function help() {
                              (default: 60000).
                              Env: DARIO_QUEUE_TIMEOUT_MS. (dario#80)
     --effort=<low|medium|high|xhigh|ultracode|max|client>
-                             Override the outbound output_config.effort
-                             on non-haiku requests. Default (unset)
-                             pins 'high' — matches CC 2.1.116's wire
-                             value. 'max' is CC's highest reasoning
-                             budget (added in CC v2.1.x; verified in
-                             v2.1.126). 'client' passes through what
-                             the client sent (falls back to 'high' if
-                             none).
-                             WARNING: non-'high' values may cause
-                             Anthropic's classifier to flip requests
-                             to 'overage' billing; watch -v logs for
+                             Pin the outbound output_config.effort on
+                             non-haiku requests, overriding the
+                             client's choice. Default (unset) forwards
+                             the client's own effort — it's a user
+                             knob; real CC wires whatever the user
+                             tuned — falling back to 'high' when the
+                             client sent none. 'client' is a compat
+                             alias for the default. 'ultracode' rides
+                             the wire as 'xhigh'.
+                             WARNING: pinned values override every
+                             client and may cause Anthropic's
+                             classifier to flip requests to 'overage'
+                             billing; watch -v logs for
                              representative-claim changes.
                              Env: DARIO_EFFORT. (dario#87)
     --max-tokens=<N|client>  Override outbound max_tokens. Default

package/dist/doctor.js

@@ -334,7 +334,7 @@ export async function runChecks(opts = {}) {
     // non-passthrough request and dominate the input-token cost on small
     // turns. Anthropic caches them after the first hit (cache_creation
     // tokens on call 1, then cache_read on subsequent calls within the
-    // 1-hour TTL), but non-CC users routing heavy tooling get
+    // 5-minute TTL), but non-CC users routing heavy tooling get
     // surprised by the first-request charge. Surface the size up front
     // so they can plan.
     //
@@ -355,7 +355,7 @@ export async function runChecks(opts = {}) {
                 detail: `${promptChars.toLocaleString()} chars system prompt + ${toolCount} tool defs ` +
                     `(${toolChars.toLocaleString()} chars JSON-serialized) injected per non-passthrough ` +
                     `request. Cached after first hit; read-cost only on subsequent calls within ` +
-                    `the 1-hour TTL. Exact token count surfaces as cache_creation_input_tokens ` +
+                    `the 5-minute TTL. Exact token count surfaces as cache_creation_input_tokens ` +
                     `on the first response (or run \`dario doctor --usage\`).`,
             });
         }

package/dist/live-fingerprint.d.ts

@@ -282,7 +282,7 @@ export declare function _resetInstalledVersionProbeForTest(): void;
  */
 export declare const SUPPORTED_CC_RANGE: {
     readonly min: "1.0.0";
-    readonly maxTested: "2.1.202";
+    readonly maxTested: "2.1.203";
 };
 /**
  * Compare two dotted-numeric version strings. Returns negative if `a<b`,

package/dist/live-fingerprint.js

@@ -542,8 +542,8 @@ export function extractTemplate(captured) {
         return null;
     // CC's system is a 3-block structure:
     //   [0] billing tag (no cache_control, tiny)
-    //   [1] agent identity ("You are Claude Code..."), cache_control 1h
-    //   [2] system prompt (~25KB), cache_control 1h
+    //   [1] agent identity ("You are Claude Code..."), cache_control ephemeral (5m — no ttl field, verified CC v2.1.203)
+    //   [2] system prompt (~25KB), cache_control ephemeral (5m)
     // Billing tag is per-request — we never cache it. Identity + prompt are
     // what we want.
     const agentIdentity = pickTextBlock(systemBlocks[1]);
@@ -786,7 +786,7 @@ export function _resetInstalledVersionProbeForTest() {
  */
 export const SUPPORTED_CC_RANGE = {
     min: '1.0.0',
-    maxTested: '2.1.202',
+    maxTested: '2.1.203',
 };
 /**
  * Compare two dotted-numeric version strings. Returns negative if `a<b`,

package/dist/proxy.js

@@ -2049,7 +2049,7 @@ export async function startProxy(opts = {}) {
                         // current Claude Code, which sends none. dario#528.
                         const cch = hasCchSeed(cliVersion) ? computeCch() : null;
                         const billingTag = buildBillingTag(cliVersion, cch);
-                        // 1h cache TTL, matching real CC (see CC_CACHE_CONTROL / dario#678).
+                        // Plain 5m ephemeral, matching real CC (see CC_CACHE_CONTROL / dario#678).
                         const CACHE_EPHEMERAL = CC_CACHE_CONTROL;
                         // Session stickiness: rebind the pre-selected pool account to
                         // whatever the sticky-key resolver picks. If this is a new

package/dist/tui/proxy-client.d.ts

@@ -70,6 +70,14 @@ export declare class ProxyClient {
      * tab can render "unknown" without crashing.
      */
     getOverageGuard(): Promise<OverageGuardStatus | null>;
+    /**
+     * Advertised model ids — GET /v1/models (the upstream-autodetected
+     * catalog with the baked fallback, so a running proxy always answers).
+     * Returns the raw id list (base ids + generated `[1m]` variants) or
+     * null on any error so the Status tab renders without a Models panel
+     * instead of crashing.
+     */
+    listModels(): Promise<string[] | null>;
     /**
      * Clear the overage-guard halt state. POSTs /admin/resume. Returns the
      * server's response (`wasHalted` indicates whether the call actually

package/dist/tui/proxy-client.js

@@ -186,6 +186,24 @@ export class ProxyClient {
             return null;
         }
     }
+    /**
+     * Advertised model ids — GET /v1/models (the upstream-autodetected
+     * catalog with the baked fallback, so a running proxy always answers).
+     * Returns the raw id list (base ids + generated `[1m]` variants) or
+     * null on any error so the Status tab renders without a Models panel
+     * instead of crashing.
+     */
+    async listModels() {
+        try {
+            const r = await this.getJson('/v1/models');
+            if (!Array.isArray(r.data))
+                return null;
+            return r.data.map((m) => String(m.id ?? '')).filter((id) => id.length > 0);
+        }
+        catch {
+            return null;
+        }
+    }
     /**
      * Clear the overage-guard halt state. POSTs /admin/resume. Returns the
      * server's response (`wasHalted` indicates whether the call actually

package/dist/tui/tabs/status.d.ts

@@ -18,6 +18,12 @@
  *   │  schema:      v1                                │
  *   │  …per-knob effective values (read-only)         │
  *   └─────────────────────────────────────────────────┘
+ *   ┌─ Models ────────────────────────────────────────┐
+ *   │  claude-fable-5      +[1m]                      │
+ *   │  claude-opus-4-8     +[1m]                      │
+ *   │  claude-sonnet-5     +[1m]                      │
+ *   │  …the advertised catalog, live from /v1/models  │
+ *   └─────────────────────────────────────────────────┘
  */
 import type { Tab, TabContext } from '../tab.js';
 import type { OverageGuardStatus } from '../proxy-client.js';
@@ -32,6 +38,8 @@ export interface StatusState {
     } | null;
     /** Config-file load source: file | missing | invalid. */
     configSource: 'file' | 'missing' | 'invalid' | null;
+    /** Advertised model ids from /v1/models — null if unreachable. */
+    models: string[] | null;
     /** Overage-guard state from /admin/resume — null if unreachable. */
     overageGuard: OverageGuardStatus | null;
     /** Transient: did we just attempt a manual resume? */
@@ -44,6 +52,18 @@ export interface StatusState {
     error: string | null;
 }
 export declare const StatusTab: Tab<StatusState>;
+/**
+ * Fold `<base>[1m]` variants onto their base id: the /v1/models listing
+ * advertises both forms for every long-context-capable family, and showing
+ * fourteen rows for seven models is noise. Preserves the catalog's order
+ * (family rank, version desc). A `[1m]`-only id with no base row (shouldn't
+ * happen — the generator always emits the pair) still gets its own row so
+ * nothing silently disappears. Exported for unit testing.
+ */
+export declare function foldLongContextVariants(ids: readonly string[]): Array<{
+    base: string;
+    has1m: boolean;
+}>;
 /**
  * Refresh the Status tab's data — probe /health, load config file
  * metadata. Exported separately so the parent can re-invoke on key

package/dist/tui/tabs/status.js

@@ -18,6 +18,12 @@
  *   │  schema:      v1                                │
  *   │  …per-knob effective values (read-only)         │
  *   └─────────────────────────────────────────────────┘
+ *   ┌─ Models ────────────────────────────────────────┐
+ *   │  claude-fable-5      +[1m]                      │
+ *   │  claude-opus-4-8     +[1m]                      │
+ *   │  claude-sonnet-5     +[1m]                      │
+ *   │  …the advertised catalog, live from /v1/models  │
+ *   └─────────────────────────────────────────────────┘
  */
 import { fg, dim, brand } from '../render.js';
 import { renderKvRow } from '../layout.js';
@@ -30,6 +36,7 @@ export const StatusTab = {
             loading: true,
             health: null,
             configSource: null,
+            models: null,
             overageGuard: null,
             resumePending: false,
             resumeMessage: null,
@@ -112,6 +119,18 @@ export const StatusTab = {
                     : dim('not loaded');
         lines.push('  ' + renderKvRow('Source', sourceLabel, w - 4));
         lines.push('');
+        // ── Models section ─────────────────────────────────────────
+        // Live from the proxy's /v1/models (upstream-autodetected catalog,
+        // baked fallback) so newly-shipped families — Sonnet 5, Fable 5 —
+        // show up here without a TUI change. `[1m]` variants are folded
+        // onto their base id as a +[1m] marker instead of doubling the list.
+        if (state.models && state.models.length > 0) {
+            lines.push(' ' + brand('Models'));
+            for (const row of foldLongContextVariants(state.models)) {
+                lines.push('  ' + renderKvRow(row.base, row.has1m ? dim('+[1m]') : '', w - 4));
+            }
+            lines.push('');
+        }
         // ── Overage-guard section (v4.1, dario#288) ────────────────
         if (state.overageGuard) {
             lines.push(' ' + brand('Overage-guard'));
@@ -144,6 +163,40 @@ export const StatusTab = {
         return lines.join('\n');
     },
 };
+/**
+ * Fold `<base>[1m]` variants onto their base id: the /v1/models listing
+ * advertises both forms for every long-context-capable family, and showing
+ * fourteen rows for seven models is noise. Preserves the catalog's order
+ * (family rank, version desc). A `[1m]`-only id with no base row (shouldn't
+ * happen — the generator always emits the pair) still gets its own row so
+ * nothing silently disappears. Exported for unit testing.
+ */
+export function foldLongContextVariants(ids) {
+    const bases = [];
+    const seen = new Map();
+    for (const id of ids) {
+        const m = id.match(/^(.*)\[1m\]$/);
+        if (m) {
+            const existing = seen.get(m[1]);
+            if (existing) {
+                existing.has1m = true;
+                continue;
+            }
+            // [1m] before (or without) its base — record under the base id.
+            const row = { base: m[1], has1m: true };
+            seen.set(m[1], row);
+            bases.push(row);
+            continue;
+        }
+        const existing = seen.get(id);
+        if (existing)
+            continue;
+        const row = { base: id, has1m: false };
+        seen.set(id, row);
+        bases.push(row);
+    }
+    return bases;
+}
 function formatDuration(ms) {
     if (ms <= 0)
         return '0s';
@@ -175,13 +228,15 @@ export async function refreshStatus(ctx) {
     catch (e) {
         error = e.message;
     }
-    // Overage-guard state — best-effort; never throws (proxy-client wraps the
-    // GET in try/catch and returns null). Surface as 'unknown' when null.
+    // Overage-guard state + model catalog — best-effort; never throw
+    // (proxy-client wraps both GETs in try/catch and returns null).
     const overageGuard = await ctx.client.getOverageGuard();
+    const models = await ctx.client.listModels();
     return {
         loading: false,
         health,
         configSource: fileResult.source,
+        models,
         overageGuard,
         resumePending: false,
         resumeMessage: null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "4.8.140",
+  "version": "4.8.142",
   "description": "Use your Claude Pro/Max subscription in any tool — Cursor, Cline, Aider, the Agent SDK, your scripts — at subscription pricing, not per-token API bills. One local Anthropic + OpenAI-compatible endpoint.",
   "type": "module",
   "bin": {