@askalf/dario 3.24.0 → 3.26.0

package/dist/cli.js

@@ -214,7 +214,13 @@ async function proxy() {
     // calc lives in src/pacing.ts; the flags just feed it.
     const pacingMinMs = parsePositiveIntFlag('--pace-min=');
     const pacingJitterMs = parsePositiveIntFlag('--pace-jitter=');
-    await startProxy({ port, host, verbose, verboseBodies, model, passthrough, preserveTools, hybridTools, noAutoDetect, strictTls, pacingMinMs, pacingJitterMs });
+    // --drain-on-close (v3.25, direction #5). When set, a client
+    // disconnect no longer aborts the upstream SSE — dario keeps
+    // draining the stream to EOF so Anthropic sees the CC-shaped
+    // read-to-completion pattern. Costs tokens (the response is fully
+    // generated even if nobody reads it), so it's opt-in.
+    const drainOnClose = args.includes('--drain-on-close') || undefined;
+    await startProxy({ port, host, verbose, verboseBodies, model, passthrough, preserveTools, hybridTools, noAutoDetect, strictTls, pacingMinMs, pacingJitterMs, drainOnClose });
 }
 function parsePositiveIntFlag(prefix) {
     const found = args.find(a => a.startsWith(prefix));
@@ -450,6 +456,11 @@ async function help() {
     dario backend remove N   Remove an OpenAI-compat backend
     dario shim -- CMD ARGS   Run CMD inside the dario shim (experimental,
                              stealth fingerprint via in-process fetch patch)
+    dario subagent install   Register ~/.claude/agents/dario.md so Claude Code
+                             can delegate dario diagnostics / template-refresh
+                             operations to a named sub-agent (v3.26)
+    dario subagent remove    Remove the registered sub-agent file
+    dario subagent status    Show whether the sub-agent is installed
     dario doctor             Print a health report: dario / Node / CC /
                              template / drift / OAuth / pool / backends
 
@@ -486,6 +497,14 @@ async function help() {
                              Default: 0 (off). Set to e.g. 300 to hide
                              the floor from long-run inter-arrival
                              statistics. (v3.24)
+    --drain-on-close         When the client disconnects mid-stream,
+                             keep consuming the upstream SSE to EOF
+                             so Anthropic sees the same read-to-
+                             completion pattern native Claude Code
+                             produces. Trades tokens (the response
+                             is fully generated even if nobody reads
+                             it) for fingerprint fidelity. Bounded by
+                             the 5-minute upstream timeout. (v3.25)
     --port=PORT              Port to listen on (default: 3456)
     --host=ADDRESS           Address to bind to (default: 127.0.0.1)
                              Use 0.0.0.0 for LAN; see README for DARIO_API_KEY
@@ -560,6 +579,74 @@ async function shim() {
         process.exit(1);
     }
 }
+async function subagent() {
+    const sub = args[1] ?? 'status';
+    const { installSubagent, removeSubagent, loadSubagentStatus, SUBAGENT_NAME } = await import('./subagent.js');
+    if (sub === 'install') {
+        const r = installSubagent();
+        console.log('');
+        console.log('  dario — Sub-agent install');
+        console.log('  ─────────────────────────');
+        console.log('');
+        if (r.action === 'unchanged') {
+            console.log(`  Already up to date at ${r.path} (v${r.version}).`);
+        }
+        else {
+            console.log(`  ${r.action === 'created' ? 'Installed' : 'Updated'} at ${r.path} (v${r.version}).`);
+        }
+        console.log('');
+        console.log('  Claude Code will pick up the new sub-agent on its next startup.');
+        console.log(`  Invoke it from CC with: "Use the ${SUBAGENT_NAME} sub-agent to …"`);
+        console.log('');
+        return;
+    }
+    if (sub === 'remove' || sub === 'uninstall') {
+        const r = removeSubagent();
+        console.log('');
+        console.log('  dario — Sub-agent remove');
+        console.log('  ────────────────────────');
+        console.log('');
+        if (r.removed) {
+            console.log(`  Removed ${r.path}.`);
+        }
+        else {
+            console.log(`  Nothing to remove — ${r.path} was not present.`);
+        }
+        console.log('');
+        return;
+    }
+    if (sub === 'status') {
+        const s = loadSubagentStatus();
+        console.log('');
+        console.log('  dario — Sub-agent status');
+        console.log('  ────────────────────────');
+        console.log('');
+        console.log(`  Path:             ${s.path}`);
+        console.log(`  ~/.claude/agents: ${s.agentsDirExists ? 'exists' : 'missing (Claude Code not installed?)'}`);
+        if (!s.installed) {
+            console.log('  Installed:        no');
+            console.log('');
+            console.log('  Install with: dario subagent install');
+        }
+        else {
+            console.log(`  Installed:        yes (v${s.fileVersion ?? 'unknown'})`);
+            if (!s.current) {
+                console.log('  Note:             file version does not match installed dario — run `dario subagent install` to refresh.');
+            }
+        }
+        console.log('');
+        return;
+    }
+    console.error('');
+    console.error('  Usage: dario subagent <install | remove | status>');
+    console.error('');
+    console.error('  install   Write ~/.claude/agents/dario.md so Claude Code can');
+    console.error('            delegate dario diagnostics to a named sub-agent.');
+    console.error('  remove    Remove the installed sub-agent file.');
+    console.error('  status    Report whether the sub-agent is installed (default).');
+    console.error('');
+    process.exit(1);
+}
 async function doctor() {
     const { runChecks, formatChecks, exitCodeFor } = await import('./doctor.js');
     console.log('');
@@ -598,6 +685,7 @@ const commands = {
     accounts,
     backend,
     shim,
+    subagent,
     doctor,
     help,
     version,

package/dist/doctor.js

@@ -197,6 +197,30 @@ export async function runChecks() {
     catch (err) {
         checks.push({ status: 'warn', label: 'Backends', detail: `check failed: ${err.message}` });
     }
+    // ---- CC sub-agent (v3.26, direction #2)
+    try {
+        const { loadSubagentStatus } = await import('./subagent.js');
+        const s = loadSubagentStatus();
+        if (!s.agentsDirExists) {
+            checks.push({ status: 'info', label: 'Sub-agent', detail: 'not installed (~/.claude/agents missing — Claude Code not installed?)' });
+        }
+        else if (!s.installed) {
+            checks.push({ status: 'info', label: 'Sub-agent', detail: 'not installed — run `dario subagent install` to enable CC integration' });
+        }
+        else if (!s.current) {
+            checks.push({
+                status: 'warn',
+                label: 'Sub-agent',
+                detail: `installed v${s.fileVersion ?? 'unknown'}, does not match this dario — run \`dario subagent install\` to refresh`,
+            });
+        }
+        else {
+            checks.push({ status: 'ok', label: 'Sub-agent', detail: `installed v${s.fileVersion} at ${s.path}` });
+        }
+    }
+    catch (err) {
+        checks.push({ status: 'warn', label: 'Sub-agent', detail: `check failed: ${err.message}` });
+    }
     // ---- ~/.dario dir
     try {
         const home = join(homedir(), '.dario');

package/dist/proxy.d.ts

@@ -15,6 +15,7 @@ interface ProxyOptions {
     strictTls?: boolean;
     pacingMinMs?: number;
     pacingJitterMs?: number;
+    drainOnClose?: boolean;
 }
 export declare function sanitizeError(err: unknown): string;
 export declare function startProxy(opts?: ProxyOptions): Promise<void>;

package/dist/proxy.js

@@ -584,6 +584,15 @@ export async function startProxy(opts = {}) {
     if (verbose) {
         console.log(`[dario] pacing: min=${pacingCfg.minGapMs}ms jitter=${pacingCfg.jitterMs}ms`);
     }
+    // Stream-consumption replay (v3.25, direction #5). When on, a client
+    // disconnect no longer aborts the upstream fetch — we keep consuming
+    // the SSE so Anthropic sees a CC-shaped read-to-EOF pattern. See
+    // src/stream-drain.ts for the rationale + tradeoff.
+    const { decideOnClientClose, resolveDrainOnClose } = await import('./stream-drain.js');
+    const drainOnClose = resolveDrainOnClose(opts.drainOnClose);
+    if (verbose) {
+        console.log(`[dario] drain-on-close: ${drainOnClose ? 'enabled' : 'disabled'}`);
+    }
     // Optional proxy authentication — pre-encode key buffer for performance
     const apiKey = process.env.DARIO_API_KEY;
     const apiKeyBuf = apiKey ? Buffer.from(apiKey) : null;
@@ -1116,11 +1125,15 @@ export async function startProxy(opts = {}) {
                 'x-stainless-timeout': '600',
             };
             // Client-disconnect abort: if the client drops the connection before
-            // we've finished sending the response, we abort the upstream fetch so
-            // Anthropic stops generating (and billing) a response nobody will
-            // read. Also carries the 5-minute upstream timeout via the same
-            // controller, so a single signal covers both cancellation reasons.
+            // we've finished sending the response, we default to aborting the
+            // upstream fetch so Anthropic stops generating (and billing) a
+            // response nobody will read. With `--drain-on-close` set, we
+            // instead keep the reader spinning to consume the full SSE — see
+            // src/stream-drain.ts for the fingerprint rationale. The 5-minute
+            // upstream timeout shares the same controller, so a hung upstream
+            // still gets cut off regardless of drain mode.
             const upstreamAbort = new AbortController();
+            let clientDisconnected = false;
             upstreamTimeout = setTimeout(() => {
                 if (!upstreamAbort.signal.aborted) {
                     upstreamAbortReason = 'timeout';
@@ -1128,13 +1141,18 @@ export async function startProxy(opts = {}) {
                 }
             }, UPSTREAM_TIMEOUT_MS);
             onClientClose = () => {
-                // 'close' fires on both normal teardown and client disconnect.
-                // We only want to abort if we haven't finished our response yet —
-                // normal teardown happens AFTER res.writableEnded becomes true.
-                if (!res.writableEnded && !upstreamAbort.signal.aborted) {
+                const action = decideOnClientClose(res.writableEnded, upstreamAbort.signal.aborted, drainOnClose);
+                if (action === 'abort') {
                     upstreamAbortReason = 'client_closed';
                     upstreamAbort.abort();
                 }
+                else if (action === 'drain') {
+                    clientDisconnected = true;
+                    if (verbose)
+                        console.log(`[dario] #${requestCount} client disconnected — draining upstream to EOF`);
+                }
+                // noop: either res is already ended (normal teardown) or upstream
+                // is already aborted for another reason.
             };
             req.on('close', onClientClose);
             const startTime = Date.now();
@@ -1448,6 +1466,14 @@ export async function startProxy(opts = {}) {
                 const streamMapper = ccToolMap && !isOpenAI
                     ? createStreamingReverseMapper(ccToolMap, reqCtx)
                     : null;
+                // Gated writer — a no-op once the downstream client has gone away
+                // in drain-on-close mode. The read loop keeps consuming so the
+                // upstream sees a full-length read; writes to a closed socket are
+                // suppressed to avoid EPIPE/warnings and pointless work.
+                const writeToClient = (chunk) => {
+                    if (!clientDisconnected)
+                        res.write(chunk);
+                };
                 try {
                     let buffer = '';
                     const MAX_LINE_LENGTH = 1_000_000; // 1MB max per SSE line
@@ -1501,8 +1527,8 @@ export async function startProxy(opts = {}) {
                                         type: 'upstream_protocol_error',
                                     },
                                 });
-                                res.write(`data: ${errPayload}\n\n`);
-                                res.write('data: [DONE]\n\n');
+                                writeToClient(`data: ${errPayload}\n\n`);
+                                writeToClient('data: [DONE]\n\n');
                                 upstreamAbortReason = 'sse_overflow';
                                 upstreamAbort.abort();
                                 break;
@@ -1512,28 +1538,28 @@ export async function startProxy(opts = {}) {
                             for (const line of lines) {
                                 const translated = translateStreamChunk(line);
                                 if (translated)
-                                    res.write(translated);
+                                    writeToClient(translated);
                             }
                         }
                         else if (streamMapper) {
                             const out = streamMapper.feed(value);
                             if (out.length > 0)
-                                res.write(out);
+                                writeToClient(out);
                         }
                         else {
-                            res.write(value);
+                            writeToClient(value);
                         }
                     }
                     // Flush remaining buffer
                     if (isOpenAI && buffer.trim()) {
                         const translated = translateStreamChunk(buffer);
                         if (translated)
-                            res.write(translated);
+                            writeToClient(translated);
                     }
                     if (streamMapper) {
                         const tail = streamMapper.end();
                         if (tail.length > 0)
-                            res.write(tail);
+                            writeToClient(tail);
                     }
                 }
                 catch (err) {

package/dist/stream-drain.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Stream-consumption replay (v3.25, direction #5 — behavioral fidelity).
+ *
+ * Native Claude Code, when it streams a response from `/v1/messages`, reads
+ * the SSE to its final event before closing the socket — even when the
+ * consumer logically already has enough. Third-party consumers routed
+ * through dario's proxy often abort mid-stream (close their request the
+ * instant they see the tool-use content block they wanted). Dario's
+ * default has been to propagate that abort upstream by triggering
+ * `upstreamAbort.abort()` from the `req.on('close')` handler — clean from
+ * a billing standpoint (Anthropic stops generating, stops billing), but a
+ * fingerprint axis: "connection closed mid-stream" vs CC's "connection
+ * read to EOF" is visible on Anthropic's side.
+ *
+ * `--drain-on-close` / `DARIO_DRAIN_ON_CLOSE=1` flips the tradeoff: when
+ * the downstream client disconnects, dario suppresses the upstream abort
+ * and keeps the reader loop spinning until the upstream emits its final
+ * event (or `UPSTREAM_TIMEOUT_MS` fires as a hard ceiling — we don't
+ * linger on dead upstreams). Writes to the closed `res` are gated off;
+ * the reads and any accumulator state (analytics, tool-map) continue so
+ * the captured usage numbers are complete rather than truncated.
+ *
+ * This has a real cost — you pay tokens for a response your consumer
+ * isn't going to read — so it's deliberately opt-in. Users on an
+ * unmetered subscription who care more about fingerprint than wasted
+ * generation can flip it on globally.
+ *
+ * This module exposes the *decision* as a pure function so the test
+ * suite can exercise every branch without spinning up a socket. The
+ * proxy wires the decision into its existing `onClientClose` handler.
+ */
+export type ClientCloseAction = 'abort' | 'drain' | 'noop';
+/**
+ * Decide what `onClientClose` should do when the client's `req.on('close')`
+ * fires. Pure over its three inputs.
+ *
+ *   `writableEnded`      — `res.writableEnded` at the moment the handler
+ *                          runs. `true` means the response is already
+ *                          finished (the 'close' event is a normal
+ *                          teardown notification after res.end()) — no
+ *                          action needed.
+ *   `upstreamAborted`    — whether upstream has already been aborted for
+ *                          some other reason (timeout, overflow, pool
+ *                          failover). Don't double-abort.
+ *   `drainOnClose`       — the runtime-configured knob.
+ *
+ * Returns:
+ *   `'noop'`  — already finished / already aborted; handler should return.
+ *   `'abort'` — fire `upstreamAbort.abort()` (the v3.24-and-earlier default).
+ *   `'drain'` — leave upstream alive; gate off client writes; let the
+ *               read loop consume to EOF (bounded by UPSTREAM_TIMEOUT_MS).
+ */
+export declare function decideOnClientClose(writableEnded: boolean, upstreamAborted: boolean, drainOnClose: boolean): ClientCloseAction;
+/**
+ * Resolve the `drainOnClose` effective setting from explicit options +
+ * `DARIO_DRAIN_ON_CLOSE` env var. Truthy env values: `'1'`, `'true'`,
+ * `'yes'` (case-insensitive). Anything else (including unset) is false.
+ * Explicit `true`/`false` on the options object always wins.
+ */
+export declare function resolveDrainOnClose(explicit: boolean | undefined, env?: NodeJS.ProcessEnv): boolean;

package/dist/stream-drain.js

@@ -0,0 +1,68 @@
+/**
+ * Stream-consumption replay (v3.25, direction #5 — behavioral fidelity).
+ *
+ * Native Claude Code, when it streams a response from `/v1/messages`, reads
+ * the SSE to its final event before closing the socket — even when the
+ * consumer logically already has enough. Third-party consumers routed
+ * through dario's proxy often abort mid-stream (close their request the
+ * instant they see the tool-use content block they wanted). Dario's
+ * default has been to propagate that abort upstream by triggering
+ * `upstreamAbort.abort()` from the `req.on('close')` handler — clean from
+ * a billing standpoint (Anthropic stops generating, stops billing), but a
+ * fingerprint axis: "connection closed mid-stream" vs CC's "connection
+ * read to EOF" is visible on Anthropic's side.
+ *
+ * `--drain-on-close` / `DARIO_DRAIN_ON_CLOSE=1` flips the tradeoff: when
+ * the downstream client disconnects, dario suppresses the upstream abort
+ * and keeps the reader loop spinning until the upstream emits its final
+ * event (or `UPSTREAM_TIMEOUT_MS` fires as a hard ceiling — we don't
+ * linger on dead upstreams). Writes to the closed `res` are gated off;
+ * the reads and any accumulator state (analytics, tool-map) continue so
+ * the captured usage numbers are complete rather than truncated.
+ *
+ * This has a real cost — you pay tokens for a response your consumer
+ * isn't going to read — so it's deliberately opt-in. Users on an
+ * unmetered subscription who care more about fingerprint than wasted
+ * generation can flip it on globally.
+ *
+ * This module exposes the *decision* as a pure function so the test
+ * suite can exercise every branch without spinning up a socket. The
+ * proxy wires the decision into its existing `onClientClose` handler.
+ */
+/**
+ * Decide what `onClientClose` should do when the client's `req.on('close')`
+ * fires. Pure over its three inputs.
+ *
+ *   `writableEnded`      — `res.writableEnded` at the moment the handler
+ *                          runs. `true` means the response is already
+ *                          finished (the 'close' event is a normal
+ *                          teardown notification after res.end()) — no
+ *                          action needed.
+ *   `upstreamAborted`    — whether upstream has already been aborted for
+ *                          some other reason (timeout, overflow, pool
+ *                          failover). Don't double-abort.
+ *   `drainOnClose`       — the runtime-configured knob.
+ *
+ * Returns:
+ *   `'noop'`  — already finished / already aborted; handler should return.
+ *   `'abort'` — fire `upstreamAbort.abort()` (the v3.24-and-earlier default).
+ *   `'drain'` — leave upstream alive; gate off client writes; let the
+ *               read loop consume to EOF (bounded by UPSTREAM_TIMEOUT_MS).
+ */
+export function decideOnClientClose(writableEnded, upstreamAborted, drainOnClose) {
+    if (writableEnded || upstreamAborted)
+        return 'noop';
+    return drainOnClose ? 'drain' : 'abort';
+}
+/**
+ * Resolve the `drainOnClose` effective setting from explicit options +
+ * `DARIO_DRAIN_ON_CLOSE` env var. Truthy env values: `'1'`, `'true'`,
+ * `'yes'` (case-insensitive). Anything else (including unset) is false.
+ * Explicit `true`/`false` on the options object always wins.
+ */
+export function resolveDrainOnClose(explicit, env = process.env) {
+    if (typeof explicit === 'boolean')
+        return explicit;
+    const v = (env.DARIO_DRAIN_ON_CLOSE ?? '').toLowerCase();
+    return v === '1' || v === 'true' || v === 'yes';
+}

package/dist/subagent.d.ts

@@ -0,0 +1,74 @@
+/**
+ * CC sub-agent hook (v3.26, direction #2).
+ *
+ * Claude Code reads sub-agent definitions from `~/.claude/agents/*.md` —
+ * a YAML-frontmatter markdown file that exposes a tool-scoped prompt
+ * context CC can delegate work into. Installing a "dario" sub-agent
+ * gives the user (or CC itself, via the Task tool) a named handle to
+ * delegate dario operations into: refreshing the baked template from
+ * a live capture, checking proxy health, listing pool / backend state.
+ *
+ * The sub-agent runs with Bash + Read tool access only — it can invoke
+ * the `dario` CLI to produce reports, but it cannot modify dario state
+ * (accounts add/remove, backend configuration, etc.) without the user
+ * explicitly running those commands in their own session. That boundary
+ * is baked into the prompt so the sub-agent doesn't accidentally take
+ * destructive actions on the user's behalf.
+ *
+ * The file content is versioned via an inline `dario-sub-agent-version:`
+ * marker so a later release can detect stale installations (same axis as
+ * the `_schemaVersion` check on the live-fingerprint cache). `readStatus`
+ * is pure over `(fileExists, fileBody)` so the tests exercise every
+ * branch without touching the filesystem.
+ */
+export declare const SUBAGENT_NAME = "dario";
+export declare const SUBAGENT_FILENAME = "dario.md";
+/** `~/.claude/agents/dario.md`. */
+export declare function getSubagentPath(): string;
+/**
+ * Construct the full sub-agent file body for a given dario version. Pure
+ * function — the tests pin the output so a change to the content is a
+ * deliberate, diffable update.
+ */
+export declare function buildSubagentFile(darioVersion: string): string;
+export interface SubagentStatus {
+    installed: boolean;
+    path: string;
+    /** Parsed from the inline `dario-sub-agent-version:` marker when the file is present. */
+    fileVersion: string | null;
+    /** Whether the installed file matches the version currently being built. */
+    current: boolean;
+    /** Whether `~/.claude/agents/` exists (is CC installed / agents dir created?). */
+    agentsDirExists: boolean;
+}
+/**
+ * Pure status computation over (fileExists, fileBody, currentVersion).
+ * Separated from `loadStatus` so tests can feed synthetic bodies and
+ * exercise every branch without the filesystem.
+ */
+export declare function computeSubagentStatus(path: string, fileExists: boolean, fileBody: string | null, agentsDirExists: boolean, currentVersion: string): SubagentStatus;
+/**
+ * Read the current on-disk status. Safe to call whether or not
+ * `~/.claude/` exists; a missing directory is reported via
+ * `agentsDirExists: false` so the caller can decide whether to create it
+ * (install) or just skip (status).
+ */
+export declare function loadSubagentStatus(): SubagentStatus;
+/**
+ * Install or refresh the sub-agent. Creates `~/.claude/agents/` if it
+ * doesn't exist. Returns what happened so the CLI can log accurately.
+ */
+export declare function installSubagent(): {
+    path: string;
+    action: 'created' | 'updated' | 'unchanged';
+    version: string;
+};
+/**
+ * Remove the sub-agent file. Idempotent — returns `{ removed: false }`
+ * if the file wasn't present. Does not remove the parent `~/.claude/agents/`
+ * directory even if it becomes empty (user may have other sub-agents).
+ */
+export declare function removeSubagent(): {
+    path: string;
+    removed: boolean;
+};

package/dist/subagent.js

@@ -0,0 +1,167 @@
+/**
+ * CC sub-agent hook (v3.26, direction #2).
+ *
+ * Claude Code reads sub-agent definitions from `~/.claude/agents/*.md` —
+ * a YAML-frontmatter markdown file that exposes a tool-scoped prompt
+ * context CC can delegate work into. Installing a "dario" sub-agent
+ * gives the user (or CC itself, via the Task tool) a named handle to
+ * delegate dario operations into: refreshing the baked template from
+ * a live capture, checking proxy health, listing pool / backend state.
+ *
+ * The sub-agent runs with Bash + Read tool access only — it can invoke
+ * the `dario` CLI to produce reports, but it cannot modify dario state
+ * (accounts add/remove, backend configuration, etc.) without the user
+ * explicitly running those commands in their own session. That boundary
+ * is baked into the prompt so the sub-agent doesn't accidentally take
+ * destructive actions on the user's behalf.
+ *
+ * The file content is versioned via an inline `dario-sub-agent-version:`
+ * marker so a later release can detect stale installations (same axis as
+ * the `_schemaVersion` check on the live-fingerprint cache). `readStatus`
+ * is pure over `(fileExists, fileBody)` so the tests exercise every
+ * branch without touching the filesystem.
+ */
+import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export const SUBAGENT_NAME = 'dario';
+export const SUBAGENT_FILENAME = `${SUBAGENT_NAME}.md`;
+/** `~/.claude/agents/dario.md`. */
+export function getSubagentPath() {
+    return join(homedir(), '.claude', 'agents', SUBAGENT_FILENAME);
+}
+/**
+ * Construct the full sub-agent file body for a given dario version. Pure
+ * function — the tests pin the output so a change to the content is a
+ * deliberate, diffable update.
+ */
+export function buildSubagentFile(darioVersion) {
+    return `---
+name: ${SUBAGENT_NAME}
+description: Use this sub-agent for dario-related diagnostics and template-refresh operations. It can invoke the \`dario\` CLI (via Bash) to run a health report, refresh the baked CC request template from a live capture, or check the proxy's account pool and backend configuration. It will not modify dario state (credentials, accounts, backends) without explicit user authorization.
+tools: Bash, Read
+---
+
+<!-- dario-sub-agent-version: ${darioVersion} -->
+<!-- managed by: dario subagent install / remove -->
+
+You are **dario's integration sub-agent**. You have access to the \`dario\` CLI via the Bash tool. Your job is to help the user with dario-related diagnostics and refresh operations by running read-only or user-requested commands and summarizing the output.
+
+## What you can do (read-only — no user confirmation required)
+
+- **\`dario doctor\`** — produce a health report covering Node / platform, runtime TLS fingerprint, CC binary + compatibility range, template source + drift, OAuth state, account pool, and backend configuration. Summarize any \`[WARN]\` or \`[FAIL]\` rows in plain language and suggest the fix hinted in the detail column.
+- **\`dario status\`** — quick auth status (authenticated, expires in, claim).
+- **\`dario accounts list\`** — list the configured account pool and per-account token expiry.
+- **\`dario backend list\`** — list configured OpenAI-compat backends (OpenRouter, Groq, LiteLLM, etc.).
+- **\`dario --version\`** — report the installed dario version.
+
+## What requires explicit user authorization first
+
+Before invoking any of these, ask the user to confirm:
+
+- \`dario login\` / \`dario refresh\` — mutates credentials.
+- \`dario accounts add/remove\` — mutates the account pool.
+- \`dario backend add/remove\` — mutates backend configuration.
+- \`dario logout\` — deletes stored credentials.
+
+## What you should NOT do
+
+- Do not run \`dario proxy\` — the proxy is a long-running server; invoking it from a sub-agent context would block the parent CC session indefinitely.
+- Do not modify \`~/.dario/\` files directly (credentials.json, accounts/, backends.json). Use the CLI.
+- Do not dump credentials, tokens, or bearer values in your output.
+
+## Style
+
+- Lead with the headline answer (one line).
+- For diagnostics, group findings by severity (FAIL → WARN → OK).
+- When suggesting a fix, quote the exact command the user should run.
+- Keep output concise — the user is delegating to you because they want a summary, not a transcript.
+`;
+}
+/**
+ * Pure status computation over (fileExists, fileBody, currentVersion).
+ * Separated from `loadStatus` so tests can feed synthetic bodies and
+ * exercise every branch without the filesystem.
+ */
+export function computeSubagentStatus(path, fileExists, fileBody, agentsDirExists, currentVersion) {
+    if (!fileExists || fileBody === null) {
+        return { installed: false, path, fileVersion: null, current: false, agentsDirExists };
+    }
+    const m = /<!-- dario-sub-agent-version: ([^ ]+) -->/.exec(fileBody);
+    const fileVersion = m ? m[1] : null;
+    const current = fileVersion === currentVersion;
+    return { installed: true, path, fileVersion, current, agentsDirExists };
+}
+/**
+ * Read the current on-disk status. Safe to call whether or not
+ * `~/.claude/` exists; a missing directory is reported via
+ * `agentsDirExists: false` so the caller can decide whether to create it
+ * (install) or just skip (status).
+ */
+export function loadSubagentStatus() {
+    const path = getSubagentPath();
+    const agentsDir = dirname(path);
+    const agentsDirExists = existsSync(agentsDir);
+    const fileExists = existsSync(path);
+    let fileBody = null;
+    if (fileExists) {
+        try {
+            fileBody = readFileSync(path, 'utf-8');
+        }
+        catch {
+            fileBody = null;
+        }
+    }
+    return computeSubagentStatus(path, fileExists, fileBody, agentsDirExists, currentDarioVersion());
+}
+/**
+ * Install or refresh the sub-agent. Creates `~/.claude/agents/` if it
+ * doesn't exist. Returns what happened so the CLI can log accurately.
+ */
+export function installSubagent() {
+    const path = getSubagentPath();
+    const agentsDir = dirname(path);
+    if (!existsSync(agentsDir)) {
+        mkdirSync(agentsDir, { recursive: true });
+    }
+    const version = currentDarioVersion();
+    const desired = buildSubagentFile(version);
+    let existingBody = null;
+    const exists = existsSync(path);
+    if (exists) {
+        try {
+            existingBody = readFileSync(path, 'utf-8');
+        }
+        catch {
+            existingBody = null;
+        }
+    }
+    if (existingBody === desired) {
+        return { path, action: 'unchanged', version };
+    }
+    writeFileSync(path, desired, 'utf-8');
+    return { path, action: exists ? 'updated' : 'created', version };
+}
+/**
+ * Remove the sub-agent file. Idempotent — returns `{ removed: false }`
+ * if the file wasn't present. Does not remove the parent `~/.claude/agents/`
+ * directory even if it becomes empty (user may have other sub-agents).
+ */
+export function removeSubagent() {
+    const path = getSubagentPath();
+    if (!existsSync(path))
+        return { path, removed: false };
+    unlinkSync(path);
+    return { path, removed: true };
+}
+function currentDarioVersion() {
+    try {
+        const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
+        return typeof pkg.version === 'string' ? pkg.version : '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "3.24.0",
+  "version": "3.26.0",
   "description": "A local LLM router. One endpoint, every provider — Claude subscriptions, OpenAI, OpenRouter, Groq, local LiteLLM, any OpenAI-compat endpoint — your tools don't need to change.",
   "type": "module",
   "bin": {
@@ -21,7 +21,7 @@
   ],
   "scripts": {
     "build": "tsc && cp src/cc-template-data.json dist/ && node -e \"require('fs').mkdirSync('dist/shim',{recursive:true})\" && cp src/shim/runtime.cjs dist/shim/",
-    "test": "node test/issue-29-tool-translation.mjs && node test/hybrid-tools.mjs && node test/tool-schema-contract.mjs && node test/scrub-paths.mjs && node test/provider-prefix.mjs && node test/analytics-recording.mjs && node test/analytics-billing-bucket.mjs && node test/failover-429.mjs && node test/pool-sticky.mjs && node test/sealed-pool.mjs && node test/live-fingerprint.mjs && node test/shim-runtime.mjs && node test/shim-e2e.mjs && node test/proxy-header-order.mjs && node test/proxy-body-order.mjs && node test/runtime-fingerprint.mjs && node test/pacing.mjs && node test/drift-detection.mjs && node test/compat-range.mjs && node test/doctor-formatter.mjs && node test/atomic-write.mjs && node test/account-refresh-singleflight.mjs && node test/streaming-edge-cases.mjs && node test/client-detection.mjs && node test/manual-oauth-flow.mjs && node test/scrub-template.mjs",
+    "test": "node test/issue-29-tool-translation.mjs && node test/hybrid-tools.mjs && node test/tool-schema-contract.mjs && node test/scrub-paths.mjs && node test/provider-prefix.mjs && node test/analytics-recording.mjs && node test/analytics-billing-bucket.mjs && node test/failover-429.mjs && node test/pool-sticky.mjs && node test/sealed-pool.mjs && node test/live-fingerprint.mjs && node test/shim-runtime.mjs && node test/shim-e2e.mjs && node test/proxy-header-order.mjs && node test/proxy-body-order.mjs && node test/runtime-fingerprint.mjs && node test/pacing.mjs && node test/stream-drain.mjs && node test/subagent.mjs && node test/drift-detection.mjs && node test/compat-range.mjs && node test/doctor-formatter.mjs && node test/atomic-write.mjs && node test/account-refresh-singleflight.mjs && node test/streaming-edge-cases.mjs && node test/client-detection.mjs && node test/manual-oauth-flow.mjs && node test/scrub-template.mjs",
     "audit": "npm audit --production --audit-level=high",
     "prepublishOnly": "npm run build",
     "start": "node dist/cli.js",