@askalf/dario 3.36.0 → 3.37.1

package/README.md

@@ -104,6 +104,7 @@ Already have **Pro + Max** stacked? Pool mode (`dario accounts add work` / `dari
 - **You want CC's behavioral constraints out of your prompt.** `dario proxy --system-prompt=partial` strips CC's Tone-and-style / Text-output / verbosity / no-comments-by-default bullets and recovers ~1.2–2.8× output capability on open-ended work — empirically without flipping subscription billing (the classifier doesn't read this slot). RLHF refusals on harmful content are unaffected (alignment is in the weights, not the prompt). See [`docs/system-prompt.md`](./docs/system-prompt.md) and the empirical writeup in [`docs/research/system-prompt.md`](./docs/research/system-prompt.md).
 - **You want dario reachable from inside Claude Code or any MCP client.** `dario subagent install` registers a CC sub-agent for in-session diagnostics ([`docs/sub-agent.md`](./docs/sub-agent.md)). `dario mcp` turns dario into a read-only MCP server ([`docs/mcp-server.md`](./docs/mcp-server.md)).
 - **You want to actually audit it.** ~12,650 lines of TypeScript across 27 files. Zero runtime dependencies. Credentials at `~/.dario/` with `0600` permissions. `127.0.0.1`-only by default. Every release [SLSA-attested](https://www.npmjs.com/package/@askalf/dario). Nothing phones home. Small enough to read in a weekend.
+- **You want a deep-research tool that runs at $0/mo.** [deepdive](https://github.com/askalf/deepdive) is dario's companion CLI — `npx @askalf/deepdive "your question"`, get a cited Markdown report. Replaces Perplexity Pro ($20/mo), OpenAI Deep Research ($20/mo), Gemini Deep Research ($20/mo) — all of which mark up LLM calls on top of LLM calls. The deep-research workload (50k–200k tokens per question, sustained) is exactly what Max was priced for; deepdive is what uses it for that.
 
 ---
 

package/dist/cc-template.d.ts

@@ -248,14 +248,14 @@ export declare const DEFAULT_MAX_TOKENS = 32000;
  * Sonnet; pinning to 32k silently truncated its output capacity).
  */
 export declare function resolveMaxTokens(flag: number | 'client' | undefined, clientBody: Record<string, unknown>): number;
-/** Valid values for the `--effort` flag. `'client'` passes through the client's own `output_config.effort` (falling back to `'high'` if the client didn't send one). dario#87. */
-export type EffortValue = 'low' | 'medium' | 'high' | 'xhigh' | 'client';
+/** Valid values for the `--effort` flag. Mirrors CC's `--effort` set as of v2.1.126 (`low|medium|high|xhigh|max`) plus dario's pseudo-value `'client'` for passthrough. `'client'` passes through the client's own `output_config.effort` (falling back to `'high'` if the client didn't send one). dario#87, `'max'` added in dario#190. */
+export type EffortValue = 'low' | 'medium' | 'high' | 'xhigh' | 'max' | 'client';
 export declare const VALID_EFFORT_VALUES: ReadonlyArray<EffortValue>;
 /**
  * Resolve the outbound `output_config.effort` value.
  *
  *   undefined / 'high' → 'high' (current default, matches CC 2.1.116 wire value)
- *   'low' / 'medium' / 'xhigh' → pin to that value
+ *   'low' / 'medium' / 'xhigh' / 'max' → pin to that value
  *   'client' → extract from `clientBody.output_config.effort`; fall back
  *              to 'high' if the client didn't send one or sent a non-string
  *

package/dist/cc-template.js

@@ -884,12 +884,12 @@ export function resolveMaxTokens(flag, clientBody) {
     }
     return flag;
 }
-export const VALID_EFFORT_VALUES = ['low', 'medium', 'high', 'xhigh', 'client'];
+export const VALID_EFFORT_VALUES = ['low', 'medium', 'high', 'xhigh', 'max', 'client'];
 /**
  * Resolve the outbound `output_config.effort` value.
  *
  *   undefined / 'high' → 'high' (current default, matches CC 2.1.116 wire value)
- *   'low' / 'medium' / 'xhigh' → pin to that value
+ *   'low' / 'medium' / 'xhigh' / 'max' → pin to that value
  *   'client' → extract from `clientBody.output_config.effort`; fall back
  *              to 'high' if the client didn't send one or sent a non-string
  *

package/dist/cli.js

@@ -957,12 +957,15 @@ async function help() {
                              dario returns 504 "queue-timeout"
                              (default: 60000).
                              Env: DARIO_QUEUE_TIMEOUT_MS. (dario#80)
-    --effort=<low|medium|high|xhigh|client>
+    --effort=<low|medium|high|xhigh|max|client>
                              Override the outbound output_config.effort
                              on non-haiku requests. Default (unset)
                              pins 'high' — matches CC 2.1.116's wire
-                             value. 'client' passes through what the
-                             client sent (falls back to 'high' if none).
+                             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
@@ -1060,6 +1063,7 @@ async function shim() {
     const rest = args.slice(1);
     const sepIdx = rest.indexOf('--');
     let verbose = false;
+    let priority = 'normal';
     let head;
     let childArgs;
     if (sepIdx >= 0) {
@@ -1073,14 +1077,23 @@ async function shim() {
     for (const flag of head) {
         if (flag === '-v' || flag === '--verbose')
             verbose = true;
+        else if (flag.startsWith('--priority=')) {
+            const v = flag.slice('--priority='.length);
+            if (v !== 'normal' && v !== 'below-normal' && v !== 'low') {
+                console.error(`--priority: invalid value ${JSON.stringify(v)}. Expected one of: normal, below-normal, low.`);
+                process.exit(1);
+            }
+            priority = v;
+        }
         else {
             console.error(`Unknown shim flag: ${flag}`);
             process.exit(1);
         }
     }
     if (childArgs.length === 0) {
-        console.error('Usage: dario shim [-v] -- <command> [args...]');
+        console.error('Usage: dario shim [-v] [--priority=normal|below-normal|low] -- <command> [args...]');
         console.error('Example: dario shim -- claude --print -p "hi"');
+        console.error('         dario shim --priority=below-normal -- claude   (recommended on Windows when RDP\'d into the host)');
         process.exit(1);
     }
     const { runShim } = await import('./shim/host.js');
@@ -1089,6 +1102,7 @@ async function shim() {
             command: childArgs[0],
             args: childArgs.slice(1),
             verbose,
+            priority,
         });
         if (verbose) {
             const summary = result.analytics.summary(60);

package/dist/shim/host.d.ts

@@ -31,6 +31,26 @@ interface RelayEvent {
     claim?: string | null;
     overageUtil?: number | null;
 }
+/**
+ * Process-priority levels accepted by the shim. Cross-platform via Node's
+ * os.setPriority — same name on every OS, different underlying class:
+ *   - 'normal'       : default, no change
+ *   - 'below-normal' : BELOW_NORMAL_PRIORITY_CLASS on Windows, nice +7 on POSIX
+ *   - 'low'          : IDLE_PRIORITY_CLASS on Windows, nice +19 on POSIX
+ *
+ * Use case: when the dario user is RDP'd into the same machine that hosts
+ * the claude CLI, claude can saturate ~4 cores during heavy tool work and
+ * starve the kernel network IO threads. The result is a Windows-specific
+ * cascade — RDP TCP socket writes return ERROR_SEM_TIMEOUT, sessions drop,
+ * Defender notices the disruption and writes a config-change event ~12s
+ * later. Lowering claude's scheduling priority lets the kernel preempt it
+ * for IO threads without changing claude's behavior or throughput. Same
+ * sustained CPU usage, no more drops. Documented in faq.md.
+ *
+ * (See dario#xxx — this lands as part of the same investigation that
+ * turned up the wider Defender / vmswitch / NIC offload cleanup work.)
+ */
+export type ShimPriority = 'normal' | 'below-normal' | 'low';
 export interface ShimHostOptions {
     /** Command to spawn (the user's claude binary, or any node-based CC wrapper). */
     command: string;
@@ -40,6 +60,13 @@ export interface ShimHostOptions {
     templatePath?: string;
     /** Print per-event lines to stderr. */
     verbose?: boolean;
+    /**
+     * Process priority for the spawned child. Defaults to 'normal' (no change).
+     * Set to 'below-normal' when running claude on a machine you're RDP'd into,
+     * so kernel network IO threads can preempt the heavy claude workload and
+     * the RDP session doesn't drop on every tool burst. See ShimPriority.
+     */
+    priority?: ShimPriority;
     /** Optional Analytics sink. If omitted, a fresh instance is created. */
     analytics?: Analytics;
 }

package/dist/shim/host.js

@@ -19,7 +19,7 @@
 import { createServer } from 'node:net';
 import { spawn } from 'node:child_process';
 import { mkdtempSync, existsSync } from 'node:fs';
-import { tmpdir, homedir } from 'node:os';
+import { tmpdir, homedir, setPriority, constants as osConstants } from 'node:os';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { Analytics } from './../analytics.js';
@@ -42,6 +42,13 @@ export function locateShimRuntime() {
     }
     throw new Error(`shim runtime not found; checked: ${candidates.join(', ')}`);
 }
+function priorityValue(p) {
+    switch (p) {
+        case 'normal': return osConstants.priority.PRIORITY_NORMAL;
+        case 'below-normal': return osConstants.priority.PRIORITY_BELOW_NORMAL;
+        case 'low': return osConstants.priority.PRIORITY_LOW;
+    }
+}
 /**
  * Pick a socket path: unix domain socket on POSIX, named pipe on Windows.
  * Both forms are accepted directly by net.createServer / net.connect.
@@ -153,6 +160,26 @@ export async function runShim(opts) {
         server.close();
         throw e;
     }
+    // Apply priority best-effort. setPriority can fail if the user lacks the
+    // privilege to lower priorities below normal (rare on Windows / Linux for
+    // the same user's process, but reported on locked-down corporate setups).
+    // We log and continue — priority is a perf optimization, not a correctness
+    // requirement. The child runs at default priority if the call fails.
+    if (opts.priority && opts.priority !== 'normal') {
+        try {
+            if (child.pid !== undefined) {
+                setPriority(child.pid, priorityValue(opts.priority));
+                if (verbose) {
+                    process.stderr.write(`[dario shim] child PID ${child.pid} priority → ${opts.priority}\n`);
+                }
+            }
+        }
+        catch (err) {
+            if (verbose) {
+                process.stderr.write(`[dario shim] priority set failed (continuing at default): ${err.message}\n`);
+            }
+        }
+    }
     const exitCode = await new Promise((resolve) => {
         child.on('exit', (code, signal) => {
             if (signal)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "3.36.0",
+  "version": "3.37.1",
   "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": {