@askalf/dario 4.8.66 → 4.8.68

package/dist/cli.js

@@ -1118,6 +1118,16 @@ async function help() {
                              (Sonnet only, Opus only when Anthropic ships
                              them), overage. Mirrors the user-dashboard
                              usage page. Costs ~1 subscription request.
+    dario doctor --obedience
+                             Probe each model family THROUGH the running
+                             proxy with a client system prompt ("reply
+                             with ONLY the word PONG") and assert the
+                             reply obeys. Catches upstream behavioral
+                             drift in client-system steering — the
+                             2026-06-12 sonnet class (dario#509) that
+                             200s, billing, and template checks all
+                             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
@@ -1672,6 +1682,7 @@ async function doctor() {
     const { runChecks, formatChecks, formatChecksJson, exitCodeFor, runAuthCheck } = await import('./doctor.js');
     const probe = args.includes('--probe');
     const usage = args.includes('--usage');
+    const obedience = args.includes('--obedience');
     const asJson = args.includes('--json');
     const authCheck = args.includes('--auth-check');
     const bunBoot = args.includes('--bun-bootstrap');
@@ -1755,7 +1766,7 @@ async function doctor() {
         console.log('');
         process.exit(result.verdict === 'match' ? 0 : 1);
     }
-    const checks = await runChecks({ probe, usage });
+    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

package/dist/doctor.d.ts

@@ -74,6 +74,28 @@ export interface IdentityDriftInput {
 }
 export declare function checkIdentityDrift(input: IdentityDriftInput): Check[];
 export declare function probeNpmLatestCC(): string | null;
+/**
+ * The client system prompt the `--obedience` probe sends. Deliberately
+ * trivial: any model that weighs client system text at all can comply,
+ * so a miss isolates "the client system prompt is being ignored" from
+ * "the instruction was too hard".
+ */
+export declare const OBEDIENCE_SYSTEM_PROMPT = "Reply with ONLY the word PONG. No other words, no punctuation, no formatting.";
+/**
+ * Join the text blocks of a `/v1/messages` response body. Thinking
+ * blocks are excluded — adaptive thinking may prepend them and they are
+ * not part of what the client-facing instruction governs. A refusal
+ * (empty content) or a malformed body yields ''.
+ */
+export declare function extractMessageText(body: unknown): string;
+/**
+ * Verdict for one obedience reply. Lenient on case and a single trailing
+ * `.`/`!` — the drift class this detects is "the model ignored the client
+ * system prompt entirely" (it answers as the CC persona instead), and a
+ * stray "Pong!" is obedient in substance. Strict equality would file
+ * 6-hourly drift issues over punctuation sampling.
+ */
+export declare function isObedientReply(text: string): boolean;
 export interface RunChecksOptions {
     /**
      * Opt-in: hit Anthropic's authorize endpoint with the scope set dario
@@ -95,6 +117,17 @@ export interface RunChecksOptions {
      * request.
      */
     usage?: boolean;
+    /**
+     * Opt-in: probe each model family THROUGH the running proxy with a
+     * client system prompt ("reply with ONLY the word PONG") and assert
+     * the reply obeys. Catches upstream behavioral drift in client-system
+     * steering — the 2026-06-12 class (dario#509) where sonnet silently
+     * stopped following client system text while every other signal
+     * (200s, subscription billing, template labels, model smoke) stayed
+     * green. Enable with `dario doctor --obedience`; costs at most
+     * `families × 3` tiny subscription requests.
+     */
+    obedience?: boolean;
 }
 /**
  * Run every available health check. Never throws — each check is

package/dist/doctor.js

@@ -148,6 +148,52 @@ export function probeNpmLatestCC() {
     _npmLatestCache = { value, at: Date.now() };
     return value;
 }
+/**
+ * One representative model per family, shared by the `--usage` probe
+ * (Anthropic only returns a family's 7d bucket header on a request TO
+ * that family) and the `--obedience` probe (behavioral drift is
+ * per-family — the 2026-06-12 regression hit sonnet while haiku obeyed
+ * the identical merged body).
+ */
+const PROBE_FAMILIES = [
+    { family: 'haiku', model: 'claude-haiku-4-5' },
+    { family: 'sonnet', model: 'claude-sonnet-4-6' },
+    { family: 'opus', model: 'claude-opus-4-8' },
+    { family: 'fable', model: 'claude-fable-5' },
+];
+/**
+ * The client system prompt the `--obedience` probe sends. Deliberately
+ * trivial: any model that weighs client system text at all can comply,
+ * so a miss isolates "the client system prompt is being ignored" from
+ * "the instruction was too hard".
+ */
+export const OBEDIENCE_SYSTEM_PROMPT = 'Reply with ONLY the word PONG. No other words, no punctuation, no formatting.';
+/**
+ * Join the text blocks of a `/v1/messages` response body. Thinking
+ * blocks are excluded — adaptive thinking may prepend them and they are
+ * not part of what the client-facing instruction governs. A refusal
+ * (empty content) or a malformed body yields ''.
+ */
+export function extractMessageText(body) {
+    const content = body?.content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .filter((b) => b?.type === 'text' && typeof b.text === 'string')
+        .map((b) => b.text)
+        .join('')
+        .trim();
+}
+/**
+ * Verdict for one obedience reply. Lenient on case and a single trailing
+ * `.`/`!` — the drift class this detects is "the model ignored the client
+ * system prompt entirely" (it answers as the CC persona instead), and a
+ * stray "Pong!" is obedient in substance. Strict equality would file
+ * 6-hourly drift issues over punctuation sampling.
+ */
+export function isObedientReply(text) {
+    return /^pong[.!]?$/i.test(text.trim());
+}
 /**
  * Run every available health check. Never throws — each check is
  * individually try/caught so a broken subsystem (e.g. unreadable accounts
@@ -475,12 +521,6 @@ export async function runChecks(opts = {}) {
             }
             // Probe each family in parallel. Anthropic only returns the
             // per-model 7d bucket header on a request TO that family.
-            const families = [
-                { family: 'haiku', model: 'claude-haiku-4-5' },
-                { family: 'sonnet', model: 'claude-sonnet-4-6' },
-                { family: 'opus', model: 'claude-opus-4-8' },
-                { family: 'fable', model: 'claude-fable-5' },
-            ];
             const probe = async (model) => {
                 const res = await fetch(probeEndpoint, {
                     method: 'POST',
@@ -499,7 +539,7 @@ export async function runChecks(opts = {}) {
                     return null;
                 return parseRateLimits(res.headers);
             };
-            const results = await Promise.all(families.map(f => probe(f.model).catch(() => null)));
+            const results = await Promise.all(PROBE_FAMILIES.map(f => probe(f.model).catch(() => null)));
             // Use the first non-null snapshot for the unified view — they
             // should all agree on the unified buckets (same account, same moment).
             const firstOk = results.find(s => s !== null);
@@ -554,6 +594,114 @@ export async function runChecks(opts = {}) {
             });
         }
     }
+    // ---- Client-system obedience probe (opt-in, --obedience).
+    // dario#509 / the 2026-06-12 deepdive 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
+    // get the JSON its system prompt demanded. This probe asserts the property
+    // those checks miss: a model, reached THROUGH the proxy's template merge,
+    // actually follows a client-supplied system instruction.
+    //
+    // Per family: up to 3 attempts (tolerates sampling), pass on the first
+    // obedient reply. Families probe in parallel, so worst-case wall time is
+    // bounded by attempts × timeout, not by family count.
+    //
+    // Requires a running proxy: a direct-to-Anthropic raw client shape would
+    // not exercise the cc-template merge seam (and Sonnet/Opus reject non-CC
+    // shapes on the subscription path anyway).
+    //
+    // Verdict semantics (consumed by scripts/check-doctor-drift.mjs):
+    //   fail = the model ANSWERED but ignored the instruction. Behavioral and
+    //          upstream-influenced — investigate the system-prompt
+    //          presentation/merge (CLIENT_SYSTEM_PREFACE, block-3 structure),
+    //          NOT necessarily a dario bug, and don't start with version
+    //          bisects (the 2026-06-12 incident burned hours on those; they
+    //          were all negative because nothing on dario's side changed).
+    //   warn = the probe never got an answer (network/429/5xx) — infra
+    //          flake, not drift.
+    if (opts.obedience) {
+        const dario_base = process.env.DARIO_TEST_URL || 'http://127.0.0.1:3456';
+        // Same auth fallback as the --usage probe: the proxy validates
+        // Authorization against DARIO_API_KEY when set; literal 'dario' is the
+        // documented loopback-only default for no-auth local proxies.
+        const dario_auth = process.env.DARIO_API_KEY || 'dario';
+        let proxyUp = false;
+        try {
+            const healthRes = await fetch(`${dario_base}/health`, { signal: AbortSignal.timeout(800) });
+            proxyUp = healthRes.ok;
+        }
+        catch { /* proxy not running */ }
+        if (!proxyUp) {
+            checks.push({
+                status: 'info',
+                label: 'Obedience',
+                detail: 'dario proxy not running — skipped. The probe must route through the proxy to exercise the client-system merge; start `dario proxy` and re-run.',
+            });
+        }
+        else {
+            const ATTEMPTS = 3;
+            const probeFamily = async ({ family, model }) => {
+                let lastReply = '';
+                let lastErr = null;
+                for (let attempt = 1; attempt <= ATTEMPTS; attempt++) {
+                    try {
+                        const res = await fetch(`${dario_base}/v1/messages`, {
+                            method: 'POST',
+                            headers: {
+                                'content-type': 'application/json',
+                                'anthropic-version': '2023-06-01',
+                                'authorization': `Bearer ${dario_auth}`,
+                            },
+                            body: JSON.stringify({
+                                model,
+                                max_tokens: 64,
+                                system: OBEDIENCE_SYSTEM_PROMPT,
+                                messages: [{ role: 'user', content: 'ping' }],
+                            }),
+                            signal: AbortSignal.timeout(30_000),
+                        });
+                        if (!res.ok) {
+                            await res.text().catch(() => '');
+                            lastErr = `HTTP ${res.status}`;
+                            continue;
+                        }
+                        const body = await res.json().catch(() => null);
+                        const text = extractMessageText(body);
+                        if (isObedientReply(text)) {
+                            return {
+                                status: 'ok',
+                                label: `Obedience (${family})`,
+                                detail: `"${text}" (attempt ${attempt}/${ATTEMPTS})`,
+                            };
+                        }
+                        // A completed-but-disobedient reply (including a refusal's
+                        // empty content) is the drift signal — remember it so it
+                        // dominates over any later transport error.
+                        lastReply = text;
+                        lastErr = null;
+                    }
+                    catch (err) {
+                        lastErr = err.message;
+                    }
+                }
+                if (lastErr !== null && lastReply === '') {
+                    return {
+                        status: 'warn',
+                        label: `Obedience (${family})`,
+                        detail: `probe could not complete (${lastErr}) — infra flake, not behavioral drift`,
+                    };
+                }
+                return {
+                    status: 'fail',
+                    label: `Obedience (${family})`,
+                    detail: `model answered but ignored the client system prompt (last reply: "${lastReply.slice(0, 80)}") — behavioral, upstream-influenced; investigate presentation/merge (CLIENT_SYSTEM_PREFACE seam), not necessarily a dario bug`,
+                };
+            };
+            const rows = await Promise.all(PROBE_FAMILIES.map((f) => probeFamily(f)));
+            checks.push(...rows);
+        }
+    }
     // ---- Account pool
     try {
         const { listAccountAliases, loadAllAccounts } = await import('./accounts.js');

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.175";
+    readonly maxTested: "2.1.176";
 };
 /**
  * Compare two dotted-numeric version strings. Returns negative if `a<b`,

package/dist/live-fingerprint.js

@@ -786,7 +786,7 @@ export function _resetInstalledVersionProbeForTest() {
  */
 export const SUPPORTED_CC_RANGE = {
     min: '1.0.0',
-    maxTested: '2.1.175',
+    maxTested: '2.1.176',
 };
 /**
  * Compare two dotted-numeric version strings. Returns negative if `a<b`,

package/package.json

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