@askalf/dario 6.19.2 → 6.20.0

package/README.md

@@ -10,6 +10,7 @@
   <a href="https://www.npmjs.com/package/@askalf/dario"><img src="https://img.shields.io/npm/v/@askalf/dario?color=6f42c1&label=npm&logo=npm" alt="npm version"></a>
   <a href="https://www.npmjs.com/package/@askalf/dario"><img src="https://img.shields.io/npm/dm/@askalf/dario?color=6f42c1" alt="Downloads"></a>
   <a href="https://github.com/askalf/dario/actions/workflows/ci.yml"><img src="https://github.com/askalf/dario/actions/workflows/ci.yml/badge.svg?branch=master" alt="CI"></a>
+  <a href="https://pitlane.askalf.org/"><img src="https://img.shields.io/endpoint?url=https%3A%2F%2Fpitlane.askalf.org%2Fbadge.json" alt="CI on pitlane"></a>
   <a href="https://scorecard.dev/viewer/?uri=github.com/askalf/dario"><img src="https://api.scorecard.dev/projects/github.com/askalf/dario/badge" alt="OpenSSF Scorecard"></a>
   <a href="https://github.com/askalf/dario/blob/master/LICENSE"><img src="https://img.shields.io/npm/l/@askalf/dario?color=6f42c1" alt="License"></a>
 </p>
@@ -117,7 +118,7 @@ dario runs entirely on your machine, authenticates as you with your own Claude l
 | Dependencies | **0 runtime.** Verify: `npm ls --production` |
 | Provenance | Every release [SLSA-attested](https://www.npmjs.com/package/@askalf/dario) via GitHub Actions + Sigstore, published with OIDC trusted publishing: no long-lived npm token exists to leak |
 | Scanning | [CodeQL](https://github.com/askalf/dario/actions/workflows/codeql.yml) on every push to master, every PR and weekly · [ClusterFuzzLite](./.github/workflows/cflite.yml) fuzzes the SSE translator, the rejection parsers and the cch stamper weekly · the [OpenSSF Scorecard](https://scorecard.dev/viewer/?uri=github.com/askalf/dario) badge above and the [Best Practices](https://www.bestpractices.dev/projects/13638) entry are live |
-| Tests | **285 test files** run in parallel by `npm test` on Node 18, 20 and 22; the live e2e / compat / stealth suites have their own entry points. Green on every release |
+| Tests | **287 test files** run in parallel by `npm test` on Node 18, 20 and 22; the live e2e / compat / stealth suites have their own entry points. Green on every release |
 | Credentials | Your own subscription tokens, never logged, redacted from errors, `0600` on disk in `0700` dirs |
 | Network | Binds `127.0.0.1` by default; upstream only to configured backends over HTTPS; hardcoded SSRF allow-list; refuses a non-loopback bind without `DARIO_API_KEY`; refuses cross-origin and DNS-rebound browser requests |
 | Telemetry | **None.** No analytics, no tracking, nothing phones home |

package/dist/admin-api.d.ts

@@ -168,7 +168,7 @@ export interface AdminCodexAccountRecord extends CodexSeatState {
     usage: CodexUsageView | null;
 }
 export interface AdminAuditEvent {
-    action: 'login_start' | 'login_complete' | 'account_remove' | 'auth_reject' | 'rate_limited' | 'key_create' | 'key_revoke' | 'key_rotate' | 'key_budget';
+    action: 'login_start' | 'login_complete' | 'account_remove' | 'auth_reject' | 'rate_limited' | 'key_create' | 'key_revoke' | 'key_rotate' | 'key_budget' | 'key_effort';
     /** Which engine's credentials the event touched; absent means Claude, the only engine before codex joined (dario#1009). */
     engine?: 'codex';
     ok: boolean;

package/dist/admin-api.js

@@ -5,7 +5,7 @@ import { startAddCodexAccount, completeAddCodexAccount, removeCodexAccount, load
 import { codexUsageView } from './codex-usage.js';
 import { parseManualPaste } from './oauth.js';
 import { grantAge } from './refresh-grant.js';
-import { createKey, revokeKey, rotateKey, parseExpiry, publicKey, setKeyBudget, normalizeBudget, KEY_NAME_RE } from './keys.js';
+import { createKey, revokeKey, rotateKey, parseExpiry, publicKey, setKeyBudget, setKeyEffort, isKeyEffort, normalizeBudget, KEY_NAME_RE, KEY_EFFORT_VALUES } from './keys.js';
 /**
  * `{ budget_usd_per_day, budget_tokens_per_day }` (numbers, or numeric strings)
  * → a KeyBudget; undefined when neither is present; throws with a 400-worthy
@@ -267,8 +267,10 @@ export async function handleAdminRequest(req, res, urlPath, deps) {
     const isKeyRotate = keyTarget !== null && keyTarget.endsWith('/rotate');
     // POST /admin/keys/<name>/budget — set or clear a key's daily caps (dario#1318 follow-up).
     const isKeyBudget = keyTarget !== null && keyTarget.endsWith('/budget');
-    const keyName = keyTarget === null ? null : isKeyRotate ? keyTarget.slice(0, -'/rotate'.length) : isKeyBudget ? keyTarget.slice(0, -'/budget'.length) : keyTarget;
-    const isKeyRevoke = keyTarget !== null && !isKeyRotate && !isKeyBudget && method === 'DELETE';
+    // POST /admin/keys/<name>/effort: set or clear a key's default effort.
+    const isKeyEffortRoute = keyTarget !== null && keyTarget.endsWith('/effort');
+    const keyName = keyTarget === null ? null : isKeyRotate ? keyTarget.slice(0, -'/rotate'.length) : isKeyBudget ? keyTarget.slice(0, -'/budget'.length) : isKeyEffortRoute ? keyTarget.slice(0, -'/effort'.length) : keyTarget;
+    const isKeyRevoke = keyTarget !== null && !isKeyRotate && !isKeyBudget && !isKeyEffortRoute && method === 'DELETE';
     const known = urlPath === '/admin/login/start' ||
         urlPath === '/admin/login/start-needed' ||
         urlPath === '/admin/login/complete' ||
@@ -281,6 +283,7 @@ export async function handleAdminRequest(req, res, urlPath, deps) {
         isAccountDelete ||
         isKeyRotate ||
         isKeyBudget ||
+        isKeyEffortRoute ||
         isKeyRevoke;
     if (!known)
         return false;
@@ -313,7 +316,7 @@ export async function handleAdminRequest(req, res, urlPath, deps) {
     // accounts' credentials for the price of one throttle token.
     const isMutation = urlPath === '/admin/login/start' || isAccountDelete
         || urlPath === '/admin/codex/login/start' || isCodexAccountDelete
-        || (urlPath === '/admin/keys' && method === 'POST') || isKeyRotate || isKeyBudget || isKeyRevoke;
+        || (urlPath === '/admin/keys' && method === 'POST') || isKeyRotate || isKeyBudget || isKeyEffortRoute || isKeyRevoke;
     if (isMutation) {
         const wait = deps.rateLimit?.('mutation') ?? 0;
         if (wait > 0) {
@@ -642,8 +645,16 @@ export async function handleAdminRequest(req, res, urlPath, deps) {
                     send(res, 400, { error: err.message });
                     return true;
                 }
+                let effort;
+                if (body.effort !== undefined && body.effort !== null) {
+                    if (!isKeyEffort(body.effort)) {
+                        send(res, 400, { error: `invalid "effort": one of ${KEY_EFFORT_VALUES.join(', ')}` });
+                        return true;
+                    }
+                    effort = body.effort;
+                }
                 try {
-                    const made = store.mutate((file) => createKey(file, name, { seat, models, expiresAt, budget, now }));
+                    const made = store.mutate((file) => createKey(file, name, { seat, models, expiresAt, budget, effort, now }));
                     deps.audit?.({ action: 'key_create', ok: true, status: 201, key: made.record.name, remote, detail: seat ? `seat=${seat}` : undefined });
                     send(res, 201, { key: publicKey(made.record, now), secret: made.secret, note: 'the secret is shown once and is not stored' });
                 }
@@ -702,6 +713,30 @@ export async function handleAdminRequest(req, res, urlPath, deps) {
                 send(res, 200, { key: publicKey(updated, now) });
                 return true;
             }
+            // POST /admin/keys/<name>/effort  { effort: "low" | ... | "max" | null }; null or absent clears.
+            if (isKeyEffortRoute) {
+                if (method !== 'POST') {
+                    send(res, 405, { error: 'Method not allowed (use POST)' });
+                    return true;
+                }
+                const body = await readJsonBody(req);
+                let effort = null;
+                if (body.effort !== undefined && body.effort !== null) {
+                    if (!isKeyEffort(body.effort)) {
+                        send(res, 400, { error: `invalid "effort": one of ${KEY_EFFORT_VALUES.join(', ')}` });
+                        return true;
+                    }
+                    effort = body.effort;
+                }
+                const updated = store.mutate((file) => setKeyEffort(file, keyName, effort));
+                deps.audit?.({ action: 'key_effort', ok: updated !== null, status: updated ? 200 : 404, key: keyName, remote, detail: effort ?? 'cleared' });
+                if (!updated) {
+                    send(res, 404, { error: `no key named "${keyName}"` });
+                    return true;
+                }
+                send(res, 200, { key: publicKey(updated, now) });
+                return true;
+            }
             // DELETE /admin/keys/<name> — revoked, kept for the list.
             if (isKeyRevoke) {
                 const revoked = store.mutate((file) => revokeKey(file, keyName));

package/dist/analytics.d.ts

@@ -18,6 +18,12 @@
  */
 import { EventEmitter } from 'node:events';
 import { type RequestTiming, type TimingStats } from './timing.js';
+/**
+ * The billed thinking count inside a usage block, or undefined when the block
+ * carries none: Anthropic's `output_tokens_details.thinking_tokens`. The
+ * number is a share of `output_tokens`, never an addition to it.
+ */
+export declare function thinkingTokensFromUsage(usage: unknown): number | undefined;
 export interface RequestRecord {
     timestamp: number;
     /**
@@ -341,7 +347,16 @@ export declare class Analytics extends EventEmitter {
      * empty list.
      */
     recent(n?: number): RequestRecord[];
-    /** Parse usage from a non-streaming Anthropic response body. */
+    /**
+     * Parse usage from a non-streaming Anthropic response body.
+     *
+     * Thinking tokens come from `usage.output_tokens_details.thinking_tokens`
+     * when the response carries it. The older estimate, a quarter of the
+     * characters in the `thinking` blocks, stays as the fallback for responses
+     * without the field, but it reads ZERO on every current model, because
+     * they return thinking blocks with empty text unless the caller asked for a
+     * summary. The usage field counts what was billed.
+     */
     static parseUsage(body: Record<string, unknown>): {
         inputTokens: number;
         outputTokens: number;

package/dist/analytics.js

@@ -19,6 +19,20 @@
 import { EventEmitter } from 'node:events';
 import { createHash } from 'node:crypto';
 import { timingStats } from './timing.js';
+/**
+ * The billed thinking count inside a usage block, or undefined when the block
+ * carries none: Anthropic's `output_tokens_details.thinking_tokens`. The
+ * number is a share of `output_tokens`, never an addition to it.
+ */
+export function thinkingTokensFromUsage(usage) {
+    if (!usage || typeof usage !== 'object')
+        return undefined;
+    const details = usage.output_tokens_details;
+    if (!details || typeof details !== 'object')
+        return undefined;
+    const n = details.thinking_tokens;
+    return typeof n === 'number' && Number.isFinite(n) && n >= 0 ? Math.round(n) : undefined;
+}
 export function continuationStats(records) {
     const out = { attempted: 0, finished: 0, unfinished: 0, failed: 0, noTarget: 0 };
     for (const r of records) {
@@ -440,14 +454,23 @@ export class Analytics extends EventEmitter {
     recent(n = 100) {
         return this.records.slice(-n);
     }
-    /** Parse usage from a non-streaming Anthropic response body. */
+    /**
+     * Parse usage from a non-streaming Anthropic response body.
+     *
+     * Thinking tokens come from `usage.output_tokens_details.thinking_tokens`
+     * when the response carries it. The older estimate, a quarter of the
+     * characters in the `thinking` blocks, stays as the fallback for responses
+     * without the field, but it reads ZERO on every current model, because
+     * they return thinking blocks with empty text unless the caller asked for a
+     * summary. The usage field counts what was billed.
+     */
     static parseUsage(body) {
         const u = body.usage;
         const content = body.content;
         const thinkingChars = content
             ?.filter(b => b.type === 'thinking')
             .reduce((s, b) => s + (b.thinking?.length ?? 0), 0) ?? 0;
-        const thinkingTokens = Math.round(thinkingChars / 4);
+        const thinkingTokens = thinkingTokensFromUsage(u) ?? Math.round(thinkingChars / 4);
         return {
             inputTokens: u?.input_tokens ?? 0,
             outputTokens: u?.output_tokens ?? 0,

package/dist/anthropic-responses-translate.d.ts

@@ -387,6 +387,8 @@ export interface ResponsesResponse {
     } | null;
     usage?: ResponsesUsage | null;
 }
+/** thinking → reasoning effort, at the same cut points as the chat path. */
+export declare function thinkingToReasoningEffort(thinking: AnthropicThinkingConfig | undefined): 'low' | 'medium' | 'high' | undefined;
 /**
  * Extra max_output_tokens reserved for reasoning tokens, by effort, so the
  * client's intended visible-output budget survives on a reasoning model

package/dist/anthropic-responses-translate.js

@@ -111,7 +111,7 @@ export function anthropicUsageFromResponses(u) {
 // Thresholds are IMPORTED so the two translators stay in lock-step.
 // ─────────────────────────────────────────────────────────────────────
 /** thinking → reasoning effort, at the same cut points as the chat path. */
-function thinkingToReasoningEffort(thinking) {
+export function thinkingToReasoningEffort(thinking) {
     if (!thinking || thinking.type !== 'enabled')
         return undefined;
     const budget = thinking.budget_tokens;

package/dist/cc-template.d.ts

@@ -156,12 +156,13 @@ export declare const CC_AGENT_IDENTITY: string;
  *   - undefined / 'verbatim' — CC's prompt unchanged (default; existing
  *     setups don't regress).
  *   - 'partial' — strip purely behavioral constraints, leaving every
- *     refusal reminder and tool description intact. On the compact CC
- *     prompt (2.1.x+) the lone behavioral constraint is the comment-
- *     density / match-surrounding-style line, swapped for a positive
- *     "be thorough" instruction; on older verbose prompts the
- *     Tone-and-style + Text-output sections and the Doing-tasks bullets
- *     are removed as well. Recovers the output capability the
+ *     refusal reminder and tool description intact. The strip runs on
+ *     the prompt CC sends for `model`: a one-line comment rule (compact
+ *     prompts, the fable variant) is swapped for a positive "be thorough"
+ *     instruction; a verbose prompt (the sonnet-5 variant) also loses its
+ *     Tone-and-style and Text-output sections and the scope, verbosity
+ *     and comment bullets in Doing tasks. A prompt with none of these is
+ *     sent unchanged. Recovers the output capability the
  *     constraint-removal research test measured.
  *   - 'aggressive' — partial + remove the prompt-level RLHF reminder (the
  *     IMPORTANT: line re-stating refusal categories) and the caution
@@ -177,7 +178,7 @@ export declare const CC_AGENT_IDENTITY: string;
  * Precedence framing inserted between CC's persona prompt and the client's
  * own system text in the merged block-3 system prompt.
  *
- * Why this exists (observed 2026-06-12, deepdive planner regression): a bare
+ * Why this exists (observed 2026-06-12, a downstream planner regression): a bare
  * `\n\n` append silently stopped working on claude-sonnet-4-6 — the model
  * followed the CC persona and treated the appended client instructions as
  * ignorable boilerplate, deterministically (0/6 on a trivial "reply with
@@ -330,7 +331,7 @@ export declare function detectTextToolClient(systemText: string): string | null;
  *   own native tools (CC_NATIVE_NAMES), so it can never present a fully-foreign
  *   surface; only a genuinely non-CC tool set can. This catches the small
  *   in-house clients the 3-tool rule below
- *   misses, e.g. forge inspection agents dispatched with just their capability
+ *   misses, e.g. in-house inspection agents dispatched with just their capability
  *   floor ([memory_store, db_query]). Before this, those 2-tool surfaces fell
  *   under a len<3 guard and got round-robined onto CC fallback slots, which
  *   silently corrupts every call (the model upstream never sees the real tool).

package/dist/cc-template.js

@@ -209,12 +209,13 @@ export const CC_AGENT_IDENTITY = TEMPLATE.agent_identity;
  *   - undefined / 'verbatim' — CC's prompt unchanged (default; existing
  *     setups don't regress).
  *   - 'partial' — strip purely behavioral constraints, leaving every
- *     refusal reminder and tool description intact. On the compact CC
- *     prompt (2.1.x+) the lone behavioral constraint is the comment-
- *     density / match-surrounding-style line, swapped for a positive
- *     "be thorough" instruction; on older verbose prompts the
- *     Tone-and-style + Text-output sections and the Doing-tasks bullets
- *     are removed as well. Recovers the output capability the
+ *     refusal reminder and tool description intact. The strip runs on
+ *     the prompt CC sends for `model`: a one-line comment rule (compact
+ *     prompts, the fable variant) is swapped for a positive "be thorough"
+ *     instruction; a verbose prompt (the sonnet-5 variant) also loses its
+ *     Tone-and-style and Text-output sections and the scope, verbosity
+ *     and comment bullets in Doing tasks. A prompt with none of these is
+ *     sent unchanged. Recovers the output capability the
  *     constraint-removal research test measured.
  *   - 'aggressive' — partial + remove the prompt-level RLHF reminder (the
  *     IMPORTANT: line re-stating refusal categories) and the caution
@@ -230,7 +231,7 @@ export const CC_AGENT_IDENTITY = TEMPLATE.agent_identity;
  * Precedence framing inserted between CC's persona prompt and the client's
  * own system text in the merged block-3 system prompt.
  *
- * Why this exists (observed 2026-06-12, deepdive planner regression): a bare
+ * Why this exists (observed 2026-06-12, a downstream planner regression): a bare
  * `\n\n` append silently stopped working on claude-sonnet-4-6 — the model
  * followed the CC persona and treated the appended client instructions as
  * ignorable boilerplate, deterministically (0/6 on a trivial "reply with
@@ -281,35 +282,48 @@ export function resolveSystemPrompt(arg, model) {
  * Port of scripts/research/test-constraint-removal.mjs:stripConstraints. Pure over
  * its input; returns the input unchanged if no target matches (so a CC
  * bump that renames sections degrades to verbatim rather than producing
- * an unpredictable strip). Handles both the verbose pre-2.1 prompt
- * (`# Tone and style` etc.) and the compact 2.1.x+ prompt; the patterns
- * for the era not in play are simply no-ops.
+ * an unpredictable strip). CC sends a different prompt per model family
+ * and each words its constraints differently: the verbose shape (headed
+ * sections and Doing-tasks bullets, e.g. the sonnet-5 variant), the
+ * compact shape's comment-density line, and the fable variant's comment
+ * paragraph. Patterns for a shape not in play are no-ops, so a prompt
+ * carrying none of them (the 2.1.316 base and the opus-5 variant) comes
+ * back unchanged. test/system-prompt-modes.mjs lists which bundled prompt
+ * carries which constraint, so a rebake that rewords one fails there.
  */
 function stripBehavioralConstraints(input, level) {
     let s = input;
-    // ── Legacy (pre-2.1 verbose prompt): no-ops on the compact prompt ──
-    s = s.replace(/# Tone and style[\s\S]*?(?=\n# |\n$|$)/m, '');
-    s = s.replace(/# Text output[^\n]*\n[\s\S]*?(?=\n# |\n$|$)/m, '');
+    // Verbose shape: whole style sections, then the Doing-tasks bullets. A
+    // section runs to the next top-level heading or the end of the prompt.
+    // The end test is (?![\s\S]), not $: under the m flag $ matches at every
+    // line end, which cut the match at the heading and left the body in.
+    s = s.replace(/^# Tone and style[\s\S]*?(?:\n(?=# )|(?![\s\S]))/m, '');
+    s = s.replace(/^# Text output[\s\S]*?(?:\n(?=# )|(?![\s\S]))/m, '');
+    // Each pattern takes one bullet plus any wrapped or nested lines under
+    // it, and stops at the next top-level bullet, heading or blank line. CC
+    // writes each bullet on one line and the next bullet is often a neutral
+    // one ("Prefer editing existing files"), so a fixed line count would
+    // delete it.
     const doingTasksConstraints = [
-        /^ - Don't add features, refactor, or introduce abstractions[^\n]*\n[^\n]*\n[^\n]*\n[^\n]*\n[^\n]*\n/m,
-        /^ - Don't add error handling, fallbacks, or validation[^\n]*\n[^\n]*\n/m,
-        /^ - Default to writing no comments\.[^\n]*\n[^\n]*\n[^\n]*\n[^\n]*\n/m,
-        /^ - Don't explain WHAT the code does[^\n]*\n[^\n]*\n/m,
-        /^ - For exploratory questions[^\n]*\n[^\n]*\n/m,
-        /^ - Avoid backwards-compatibility hacks[^\n]*\n[^\n]*\n/m,
+        /^ - Don't add features, refactor, or introduce abstractions[^\n]*\n(?:(?! - |#)[^\n]+\n)*/m,
+        /^ - Don't add error handling, fallbacks, or validation[^\n]*\n(?:(?! - |#)[^\n]+\n)*/m,
+        /^ - Default to writing no comments\.[^\n]*\n(?:(?! - |#)[^\n]+\n)*/m,
+        /^ - Don't explain WHAT the code does[^\n]*\n(?:(?! - |#)[^\n]+\n)*/m,
+        /^ - For exploratory questions[^\n]*\n(?:(?! - |#)[^\n]+\n)*/m,
+        /^ - Avoid backwards-compatibility hacks[^\n]*\n(?:(?! - |#)[^\n]+\n)*/m,
     ];
     for (const re of doingTasksConstraints) {
         s = s.replace(re, '');
     }
     s = s.replace(/^# Doing tasks\n/m, '# Doing tasks\n\nBe thorough. Show your reasoning. Provide the context and explanations the user is likely to find useful. Use as many tokens as the task warrants.\n\n');
-    // ── Compact prompt (2.1.x+): its one behavioral constraint is the
-    // comment-density / match-surrounding-style line. Swap it for the same
-    // positive instruction the legacy Doing-tasks rewrite inserts. ──
-    s = s.replace(/^Write code that reads like the surrounding code:[^\n]*\n/m, 'Be thorough. Show your reasoning. Provide the context and explanations the user is likely to find useful. Use as many tokens as the task warrants.\n');
+    // Compact shape and the fable variant: the comment constraint is one
+    // unheaded line. Swap it for the same positive instruction the
+    // Doing-tasks rewrite inserts.
+    s = s.replace(/^(?:Write code that reads like the surrounding code:|Only write a code comment to state a constraint)[^\n]*\n/gm, 'Be thorough. Show your reasoning. Provide the context and explanations the user is likely to find useful. Use as many tokens as the task warrants.\n');
     if (level === 'aggressive') {
         s = s.replace(/^IMPORTANT: Assist with authorized security testing[^\n]*\n/m, '');
         s = s.replace(/^IMPORTANT: You must NEVER generate or guess URLs[^\n]*\n/m, '');
-        s = s.replace(/# Executing actions with care[\s\S]*?(?=\n# |\n$|$)/m, '');
+        s = s.replace(/^# Executing actions with care[\s\S]*?(?:\n(?=# )|(?![\s\S]))/m, '');
         // Compact prompt: the caution guidance is a single unheaded paragraph.
         s = s.replace(/^For actions that are hard to reverse or outward-facing,[^\n]*\n/m, '');
     }
@@ -712,7 +726,7 @@ export function detectTextToolClient(systemText) {
  *   own native tools (CC_NATIVE_NAMES), so it can never present a fully-foreign
  *   surface; only a genuinely non-CC tool set can. This catches the small
  *   in-house clients the 3-tool rule below
- *   misses, e.g. forge inspection agents dispatched with just their capability
+ *   misses, e.g. in-house inspection agents dispatched with just their capability
  *   floor ([memory_store, db_query]). Before this, those 2-tool surfaces fell
  *   under a len<3 guard and got round-robined onto CC fallback slots, which
  *   silently corrupts every call (the model upstream never sees the real tool).

package/dist/cli.js

@@ -19,7 +19,7 @@
 import { unlink, writeFile } from 'node:fs/promises';
 import { formatLedgerSummary, formatLedgerConsumers, formatUsd, renderLedgerCard, readLedgerFile, resolveLedgerPath, summarizeLedger } from './ledger.js';
 import { renderSpendDonuts } from './donuts.js';
-import { KeyStore, createKey, revokeKey, rotateKey, deleteKey, parseExpiry, publicKey, resolveKeysPath, KEY_NAME_RE, parseKeySocketSpec, setKeyBudget, parseUsdBudget, parseTokenBudget, formatBudget } from './keys.js';
+import { KeyStore, createKey, revokeKey, rotateKey, deleteKey, parseExpiry, publicKey, resolveKeysPath, KEY_NAME_RE, parseKeySocketSpec, setKeyBudget, setKeyEffort, isKeyEffort, KEY_EFFORT_VALUES, parseUsdBudget, parseTokenBudget, formatBudget } from './keys.js';
 /**
  * `--budget=$5/day` / `--budget-tokens=2M/day` → a KeyBudget, or undefined when
  * neither flag is present. A flag that does not parse exits 1 with the accepted
@@ -875,9 +875,9 @@ async function keys() {
             return;
         }
         const w = Math.max(4, ...list.map((k) => k.name.length));
-        console.log(`  ${'NAME'.padEnd(w)}  ${'STATUS'.padEnd(7)}  ${'SEAT'.padEnd(12)}  ${'LAST USED'.padEnd(10)}  ${'EXPIRES'.padEnd(10)}  ${'BUDGET'.padEnd(20)}  MODELS`);
+        console.log(`  ${'NAME'.padEnd(w)}  ${'STATUS'.padEnd(7)}  ${'SEAT'.padEnd(12)}  ${'EFFORT'.padEnd(6)}  ${'LAST USED'.padEnd(10)}  ${'EXPIRES'.padEnd(10)}  ${'BUDGET'.padEnd(20)}  MODELS`);
         for (const k of list) {
-            console.log(`  ${k.name.padEnd(w)}  ${k.status.padEnd(7)}  ${(k.seat ?? '-').padEnd(12)}  ${fmtAgo(k.last_used).padEnd(10)}  ${fmtDay(k.expires).padEnd(10)}  ${formatBudget(k.budget ? { usdPerDay: k.budget.usd_per_day ?? undefined, tokensPerDay: k.budget.tokens_per_day ?? undefined } : null).padEnd(20)}  ${k.models.length ? k.models.join(', ') : 'any'}`);
+            console.log(`  ${k.name.padEnd(w)}  ${k.status.padEnd(7)}  ${(k.seat ?? '-').padEnd(12)}  ${(k.effort ?? '-').padEnd(6)}  ${fmtAgo(k.last_used).padEnd(10)}  ${fmtDay(k.expires).padEnd(10)}  ${formatBudget(k.budget ? { usdPerDay: k.budget.usd_per_day ?? undefined, tokensPerDay: k.budget.tokens_per_day ?? undefined } : null).padEnd(20)}  ${k.models.length ? k.models.join(', ') : 'any'}`);
         }
         console.log('');
         console.log(`  ${list.length} key${list.length === 1 ? '' : 's'} in ${path}. Spend per key: dario usage --by-key`);
@@ -888,7 +888,7 @@ async function keys() {
         const name = args[2];
         if (!name || name.startsWith('--')) {
             console.error('');
-            console.error('  Usage: dario keys create <name> [--seat=<alias>] [--models=a,b,prefix*] [--expires=30d|12h|2w|<ISO date>] [--budget=$5/day] [--budget-tokens=2M/day]');
+            console.error('  Usage: dario keys create <name> [--seat=<alias>] [--models=a,b,prefix*] [--expires=30d|12h|2w|<ISO date>] [--budget=$5/day] [--budget-tokens=2M/day] [--effort=low|medium|high|xhigh|max]');
             console.error('');
             process.exit(1);
         }
@@ -907,8 +907,14 @@ async function keys() {
             expiresAt = parsed;
         }
         const budget = readBudgetFlags(args);
+        const effortArg = args.find((a) => a.startsWith('--effort='));
+        const effort = effortArg ? effortArg.slice('--effort='.length).trim().toLowerCase() : undefined;
+        if (effort !== undefined && !isKeyEffort(effort)) {
+            console.error(`[dario] --effort: "${effort}" is not one of ${KEY_EFFORT_VALUES.join(', ')}.`);
+            process.exit(1);
+        }
         try {
-            const made = store.mutate((file) => createKey(file, name, { seat, models, expiresAt, budget, now }));
+            const made = store.mutate((file) => createKey(file, name, { seat, models, expiresAt, budget, effort, now }));
             printSecret('created', publicKey(made.record, now), made.secret);
         }
         catch (err) {
@@ -917,6 +923,34 @@ async function keys() {
         }
         return;
     }
+    // dario keys effort <name> low|medium|high|xhigh|max | --clear
+    if (sub === 'effort') {
+        const name = args[2];
+        const raw = args.includes('--clear') ? null : (args[3] ?? '').trim().toLowerCase();
+        if (!name || !KEY_NAME_RE.test(name) || (raw !== null && !isKeyEffort(raw))) {
+            console.error('');
+            console.error(`  Usage: dario keys effort <name> ${KEY_EFFORT_VALUES.join('|')} | --clear`);
+            console.error('');
+            console.error('  The effort this key\'s requests run at when they name none themselves (no model-name');
+            console.error('  suffix, no effort field in the body). --effort / DARIO_EFFORT still wins over it.');
+            console.error('');
+            process.exit(1);
+        }
+        const level = raw !== null && isKeyEffort(raw) ? raw : null;
+        try {
+            const updated = store.mutate((file) => setKeyEffort(file, name, level));
+            if (!updated) {
+                console.error(`[dario] No key named "${name}".`);
+                process.exit(1);
+            }
+            console.log(level ? `[dario] Key "${name}" default effort: ${level}` : `[dario] Key "${name}" default effort cleared.`);
+        }
+        catch (err) {
+            console.error(`[dario] ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        }
+        return;
+    }
     // dario keys budget <name> --budget=$5/day --budget-tokens=2M/day | --clear
     if (sub === 'budget') {
         const name = args[2];
@@ -985,7 +1019,7 @@ async function keys() {
         return;
     }
     console.error(`[dario] Unknown keys subcommand: ${sub}`);
-    console.error('Usage: dario keys [list|create <name> [--seat=..] [--models=..] [--expires=..] [--budget=..] [--budget-tokens=..]|budget <name> ..|revoke <name>|rotate <name>|remove <name>] [--json] [--keys-path=<file>]');
+    console.error('Usage: dario keys [list|create <name> [--seat=..] [--models=..] [--expires=..] [--budget=..] [--budget-tokens=..] [--effort=..]|budget <name> ..|effort <name> <level>|--clear|revoke <name>|rotate <name>|remove <name>] [--json] [--keys-path=<file>]');
     process.exit(1);
 }
 /**
@@ -2025,8 +2059,8 @@ async function help() {
                              miss. Needs \`dario proxy\` running; costs
                              at most a few tiny subscription requests.
     dario doctor --json      Emit the check report as structured JSON
-                             for machine consumption (claude-bridge
-                             /status, CI scripts, etc.) instead of the
+                             for machine consumption (status bots,
+                             CI scripts, etc.) instead of the
                              human-readable table.
     dario doctor --auth-check
                              One-shot listener on an ephemeral loopback
@@ -2759,8 +2793,8 @@ async function doctor() {
     }
     const checks = await runChecks({ probe, usage, obedience });
     if (asJson) {
-        // JSON mode is meant for machine consumption (claude-bridge /status,
-        // deepdive health checks, CI scripts) — no decorative header, no
+        // JSON mode is meant for machine consumption (status bots, health
+        // checks, CI scripts): no decorative header, no
         // trailing prose, stable shape. Exit code is also surfaced in the
         // JSON envelope for callers that can't read process exit codes.
         process.stdout.write(formatChecksJson(checks) + '\n');

package/dist/doctor-core.d.ts

@@ -108,7 +108,7 @@ export declare function formatChecks(checks: Check[]): string;
 export declare function exitCodeFor(checks: Check[]): number;
 /**
  * Serialize a check report as structured JSON. Lets other tools
- * (claude-bridge's /status command, deepdive, CI scripts) consume
+ * (chat-bot /status commands, health probes, CI scripts) consume
  * dario's health programmatically instead of scraping the formatted
  * text. Emitted by `dario doctor --json`.
  */

package/dist/doctor-core.js

@@ -227,7 +227,7 @@ export function exitCodeFor(checks) {
 }
 /**
  * Serialize a check report as structured JSON. Lets other tools
- * (claude-bridge's /status command, deepdive, CI scripts) consume
+ * (chat-bot /status commands, health probes, CI scripts) consume
  * dario's health programmatically instead of scraping the formatted
  * text. Emitted by `dario doctor --json`.
  */
@@ -1019,7 +1019,7 @@ export async function runChecks(opts = {}) {
         }
     }
     // ---- Client-system obedience probe (opt-in, --obedience).
-    // dario#509 / the 2026-06-12 deepdive planner outage: Anthropic's serving
+    // dario#509 / the 2026-06-12 downstream planner outage: Anthropic's serving
     // side changed how claude-sonnet-4-6 weighed client system text merged
     // after the CC persona in block 3 — wire bytes identical, every existing
     // check green — and the only symptom was a downstream consumer failing to

package/dist/effort.d.ts

@@ -32,6 +32,24 @@ export declare const VALID_EFFORT_VALUES: ReadonlyArray<EffortValue>;
  *     and the request's own thinking budget decides, as before.
  */
 export declare function effortForCodex(effort: EffortValue | undefined): 'low' | 'medium' | 'high' | 'xhigh' | 'max' | undefined;
+/**
+ * Did the request name an effort of its own? Three places a client can say it:
+ * `output_config.effort` (Messages shape), `reasoning_effort` (chat completions),
+ * `reasoning.effort` (Responses). A named key's default effort fills in only when
+ * this is false, so a client that chose is never overruled by a default. The
+ * model-name suffix is checked separately by the caller (it is parsed off the
+ * model before this runs).
+ */
+export declare function requestNamesEffort(body: Record<string, unknown> | null | undefined): boolean;
+/**
+ * A Responses body for the codex passthrough with `reasoning.effort` filled in.
+ * Returned as is when there is no effort to add or when the client already
+ * named one (a non-empty `reasoning.effort`); otherwise a copy carries the
+ * level and keeps every other `reasoning` field, since Codex CLI sends
+ * `summary` there. The passthrough forwards the client's body as written, so
+ * this is the only place a suffix or a key default can reach that route.
+ */
+export declare function withResponsesEffort(body: Record<string, unknown>, effort: 'low' | 'medium' | 'high' | 'xhigh' | 'max' | undefined): Record<string, unknown>;
 export declare function parseEffortSuffix(model: string): {
     model: string;
     effort?: EffortValue;

package/dist/effort.js

@@ -52,6 +52,44 @@ export function effortForCodex(effort) {
         default: return undefined;
     }
 }
+/**
+ * Did the request name an effort of its own? Three places a client can say it:
+ * `output_config.effort` (Messages shape), `reasoning_effort` (chat completions),
+ * `reasoning.effort` (Responses). A named key's default effort fills in only when
+ * this is false, so a client that chose is never overruled by a default. The
+ * model-name suffix is checked separately by the caller (it is parsed off the
+ * model before this runs).
+ */
+export function requestNamesEffort(body) {
+    if (!body || typeof body !== 'object')
+        return false;
+    const oc = body.output_config;
+    if (oc && typeof oc === 'object' && typeof oc.effort === 'string')
+        return true;
+    if (typeof body.reasoning_effort === 'string' && body.reasoning_effort.length > 0)
+        return true;
+    const reasoning = body.reasoning;
+    if (reasoning && typeof reasoning === 'object' && typeof reasoning.effort === 'string')
+        return true;
+    return false;
+}
+/**
+ * A Responses body for the codex passthrough with `reasoning.effort` filled in.
+ * Returned as is when there is no effort to add or when the client already
+ * named one (a non-empty `reasoning.effort`); otherwise a copy carries the
+ * level and keeps every other `reasoning` field, since Codex CLI sends
+ * `summary` there. The passthrough forwards the client's body as written, so
+ * this is the only place a suffix or a key default can reach that route.
+ */
+export function withResponsesEffort(body, effort) {
+    if (!effort)
+        return body;
+    const r = body.reasoning;
+    const existing = r !== null && typeof r === 'object' && !Array.isArray(r) ? r : {};
+    if (typeof existing.effort === 'string' && existing.effort.length > 0)
+        return body;
+    return { ...body, reasoning: { ...existing, effort } };
+}
 export function parseEffortSuffix(model) {
     for (const e of SUFFIX_EFFORTS) {
         for (const sep of [':', '-']) {

package/dist/keys.d.ts

@@ -3,6 +3,14 @@ export declare const KEY_PREFIX = "dk_";
 /** Same charset as a pool alias — a key name is printed next to one. */
 export declare const KEY_NAME_RE: RegExp;
 export declare const KEYS_FLUSH_DELAY_MS = 3000;
+/**
+ * The effort levels a named key may carry as its default: the wire-valid set,
+ * and nothing that means "ask the client" (`client`) or names a client mode
+ * (`ultracode`). Applied per request when the request named no effort itself.
+ */
+export type KeyEffort = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+export declare const KEY_EFFORT_VALUES: ReadonlyArray<KeyEffort>;
+export declare function isKeyEffort(v: unknown): v is KeyEffort;
 export interface KeyRecord {
     /** Stable short id (8 hex), for logs and rotation; never the secret. */
     id: string;
@@ -23,6 +31,12 @@ export interface KeyRecord {
     models?: string[];
     /** Daily caps, UTC day, enforced from the ledger (dario#1318 follow-up). Absent = unlimited. */
     budget?: KeyBudget;
+    /**
+     * Default effort for this key's requests when the request names none itself
+     * (no model-name suffix, no effort field in the body). Absent = the proxy's
+     * usual resolution. The operator's --effort pin still wins over it.
+     */
+    effort?: KeyEffort;
 }
 /**
  * A key's daily budget. Both caps are per UTC day and both are read from the
@@ -126,6 +140,8 @@ export declare function budgetVerdict(budget: KeyBudget, usage: KeyBudgetUsage,
 export declare function budgetHeaders(v: KeyBudgetVerdict, keyName: string): Record<string, string>;
 /** Replace (or clear, with null) a key's budget. Null result: no such key. */
 export declare function setKeyBudget(file: KeysFile, name: string, budget: KeyBudget | null): KeyRecord | null;
+/** Set or clear a key's default effort. Returns null when there is no such key; throws on a level outside KEY_EFFORT_VALUES. */
+export declare function setKeyEffort(file: KeysFile, name: string, effort: KeyEffort | string | null): KeyRecord | null;
 export interface KeysFile {
     version: number;
     keys: KeyRecord[];
@@ -161,6 +177,8 @@ export interface CreateKeyOptions {
     budget?: KeyBudget;
     /** Absolute expiry, epoch ms. */
     expiresAt?: number;
+    /** Default effort; one of KEY_EFFORT_VALUES, validated. */
+    effort?: string;
     now?: number;
 }
 /** Mint a key. Returns the record (stored) and the secret (shown once). Mutates `file`. */
@@ -203,6 +221,8 @@ export interface KeyPublic {
         usd_per_day: number | null;
         tokens_per_day: number | null;
     } | null;
+    /** Default effort, or null when the key has none. */
+    effort: KeyEffort | null;
 }
 export declare function publicKey(k: KeyRecord, now?: number): KeyPublic;
 /** `--expires=30d` / `12h` / `2026-12-31` → epoch ms, or null when unparseable. */