@askalf/dario 5.5.25 → 5.5.28

package/dist/cc-template.d.ts

@@ -7,74 +7,14 @@
  * live cache self-heals when Anthropic ships a new CC version — no user
  * action required. See src/live-fingerprint.ts for the capture pipeline.
  */
-import { TemplateData } from './live-fingerprint.js';
+import { TemplateData, PLATFORM_ONLY_TOOLS, INTERACTIVE_ONLY_TOOLS, CONFIG_SCOPED_TOOLS } from './live-fingerprint.js';
+export { PLATFORM_ONLY_TOOLS, INTERACTIVE_ONLY_TOOLS, CONFIG_SCOPED_TOOLS };
 /** The loaded template itself — source, version, capture age, all fields. Startup banners and drift checks read this directly. */
 export declare const CC_TEMPLATE: TemplateData;
-/**
- * Tools CC only ships on a specific platform. The bundled template is a
- * union capture (any platform the maintainer baked from), so we filter it
- * down to the running platform at module load. Real CC on the client side
- * only advertises the tools available to its host — forwarding a larger
- * set through dario would both leak a fingerprint (Anthropic sees tools
- * the client would never actually call) and risk tool_use round-trips
- * coming back for a tool the client has no handler for.
- *
- * PowerShell shipped in CC v2.1.116 on Windows; POSIX CC installs do not
- * advertise it. As of CC v2.1.162 the Glob/Grep tools are the same shape:
- * Windows CC advertises them, POSIX CC drops them and steers the agent to
- * shell `find`/`grep` instead (which PowerShell has no native equivalent
- * for). Registering them here filters them to win32 clients AND keeps a
- * POSIX auto-bake from dropping them out of the union — the v4.8.28
- * regression, where a Linux runner re-baked the bundle down to 28 tools.
- * Add new platform-scoped tools here as CC adds them.
- */
-export declare const PLATFORM_ONLY_TOOLS: Record<string, Set<string>>;
 /** Keep tool `t` unless its name is listed under a platform other than the current one. */
 export declare function filterToolsForPlatform<T extends {
     name: string;
 }>(tools: T[], platform: string): T[];
-/**
- * Tools CC only advertises in an INTERACTIVE session. The bake captures CC
- * headlessly (`claude --print -p hi`, see live-fingerprint.ts), and CC v2.1.187
- * dropped these plan-mode / clarification tools in `--print` mode — so a fresh
- * headless capture no longer carries them even though every real interactive CC
- * client still advertises them. Like PLATFORM_ONLY_TOOLS, the bundled template
- * must stay a SUPERSET: register them here so a headless auto-rebake preserves
- * them from the previous bundle instead of dropping them. Dropping them broke
- * buildCCRequest's advertise-respects-client contract (the v4.8.93 regression):
- * dario advertises only the intersection of the client's declared tools and this
- * template, so a missing AskUserQuestion meant dario could not advertise it even
- * when a full CC client declared it. Unlike PLATFORM_ONLY_TOOLS these are NOT
- * platform-filtered — they stay in CC_TOOL_DEFINITIONS on every host so a client
- * that declares them is always honored. Add new interactive-only tools here as
- * CC adds them.
- */
-export declare const INTERACTIVE_ONLY_TOOLS: Set<string>;
-/**
- * Tools CC advertises only under some runtime configurations. Unlike
- * INTERACTIVE_ONLY_TOOLS (absent because the bake captures headlessly), these
- * come and go with CC's REMOTE config for the same capture mode: the 2026-08-11
- * bake on CC v2.1.232 captured all four headlessly, and the 2026-08-15 bake on
- * v2.1.233 captured none of them — while TaskOutput/TaskStop, the rest of the
- * task subsystem, stayed put. That is the v4.2.1 drift class (same binary,
- * different wire shape via remote configuration), and it is not a signal that
- * CC retired the tools.
- *
- * The bundle must stay a SUPERSET, so the bake preserves these from the previous
- * bundle exactly as it does the platform- and interactive-only sets. The cost of
- * the two directions is asymmetric, which is what settles it: a stale entry is
- * INERT, because buildCCRequest advertises only the intersection of the bundle
- * with what the client declared — no client declares it, nothing is advertised.
- * Dropping one is NOT inert: CC_NATIVE_NAMES_UNION is derived from this bundle,
- * so a client that does declare TaskCreate stops identity-mapping, falls into
- * the unmapped round-robin, and is renamed onto a fallback slot with junk args
- * (the v4.8.93 regression, caught here by issue-29-tool-translation.mjs).
- *
- * Add new config-scoped tools here as CC's remote config churns. Removing a name
- * is a deliberate act: it means CC genuinely retired the tool, and it should be
- * paired with the capture evidence that says so.
- */
-export declare const CONFIG_SCOPED_TOOLS: Set<string>;
 /** CC's exact tool definitions for the current platform — filtered from the bundled union. */
 export declare const CC_TOOL_DEFINITIONS: {
     name: string;

package/dist/cc-template.js

@@ -7,32 +7,17 @@
  * live cache self-heals when Anthropic ships a new CC version — no user
  * action required. See src/live-fingerprint.ts for the capture pipeline.
  */
-import { loadTemplate, promptVariantsOf, VARIANT_FAMILIES } from './live-fingerprint.js';
+import { loadTemplate, promptVariantsOf, VARIANT_FAMILIES, PLATFORM_ONLY_TOOLS, INTERACTIVE_ONLY_TOOLS, CONFIG_SCOPED_TOOLS, } from './live-fingerprint.js';
+// Re-exported so existing importers (scripts/capture-and-bake.mjs, the template
+// invariant tests) keep their import site. The definitions live in
+// live-fingerprint.ts because loadTemplate must apply the same superset rule to
+// a live capture that the bake applies to the bundle, and cc-template.ts is
+// downstream of that load (#1035).
+export { PLATFORM_ONLY_TOOLS, INTERACTIVE_ONLY_TOOLS, CONFIG_SCOPED_TOOLS };
 // Load template at module init — prefer live cache, fall back to bundled.
 const TEMPLATE = loadTemplate({ silent: true });
 /** The loaded template itself — source, version, capture age, all fields. Startup banners and drift checks read this directly. */
 export const CC_TEMPLATE = TEMPLATE;
-/**
- * Tools CC only ships on a specific platform. The bundled template is a
- * union capture (any platform the maintainer baked from), so we filter it
- * down to the running platform at module load. Real CC on the client side
- * only advertises the tools available to its host — forwarding a larger
- * set through dario would both leak a fingerprint (Anthropic sees tools
- * the client would never actually call) and risk tool_use round-trips
- * coming back for a tool the client has no handler for.
- *
- * PowerShell shipped in CC v2.1.116 on Windows; POSIX CC installs do not
- * advertise it. As of CC v2.1.162 the Glob/Grep tools are the same shape:
- * Windows CC advertises them, POSIX CC drops them and steers the agent to
- * shell `find`/`grep` instead (which PowerShell has no native equivalent
- * for). Registering them here filters them to win32 clients AND keeps a
- * POSIX auto-bake from dropping them out of the union — the v4.8.28
- * regression, where a Linux runner re-baked the bundle down to 28 tools.
- * Add new platform-scoped tools here as CC adds them.
- */
-export const PLATFORM_ONLY_TOOLS = {
-    win32: new Set(['PowerShell', 'Glob', 'Grep']),
-};
 /** Keep tool `t` unless its name is listed under a platform other than the current one. */
 export function filterToolsForPlatform(tools, platform) {
     return tools.filter((tool) => {
@@ -43,57 +28,6 @@ export function filterToolsForPlatform(tools, platform) {
         return true;
     });
 }
-/**
- * Tools CC only advertises in an INTERACTIVE session. The bake captures CC
- * headlessly (`claude --print -p hi`, see live-fingerprint.ts), and CC v2.1.187
- * dropped these plan-mode / clarification tools in `--print` mode — so a fresh
- * headless capture no longer carries them even though every real interactive CC
- * client still advertises them. Like PLATFORM_ONLY_TOOLS, the bundled template
- * must stay a SUPERSET: register them here so a headless auto-rebake preserves
- * them from the previous bundle instead of dropping them. Dropping them broke
- * buildCCRequest's advertise-respects-client contract (the v4.8.93 regression):
- * dario advertises only the intersection of the client's declared tools and this
- * template, so a missing AskUserQuestion meant dario could not advertise it even
- * when a full CC client declared it. Unlike PLATFORM_ONLY_TOOLS these are NOT
- * platform-filtered — they stay in CC_TOOL_DEFINITIONS on every host so a client
- * that declares them is always honored. Add new interactive-only tools here as
- * CC adds them.
- */
-export const INTERACTIVE_ONLY_TOOLS = new Set([
-    'AskUserQuestion',
-    'EnterPlanMode',
-    'ExitPlanMode',
-]);
-/**
- * Tools CC advertises only under some runtime configurations. Unlike
- * INTERACTIVE_ONLY_TOOLS (absent because the bake captures headlessly), these
- * come and go with CC's REMOTE config for the same capture mode: the 2026-08-11
- * bake on CC v2.1.232 captured all four headlessly, and the 2026-08-15 bake on
- * v2.1.233 captured none of them — while TaskOutput/TaskStop, the rest of the
- * task subsystem, stayed put. That is the v4.2.1 drift class (same binary,
- * different wire shape via remote configuration), and it is not a signal that
- * CC retired the tools.
- *
- * The bundle must stay a SUPERSET, so the bake preserves these from the previous
- * bundle exactly as it does the platform- and interactive-only sets. The cost of
- * the two directions is asymmetric, which is what settles it: a stale entry is
- * INERT, because buildCCRequest advertises only the intersection of the bundle
- * with what the client declared — no client declares it, nothing is advertised.
- * Dropping one is NOT inert: CC_NATIVE_NAMES_UNION is derived from this bundle,
- * so a client that does declare TaskCreate stops identity-mapping, falls into
- * the unmapped round-robin, and is renamed onto a fallback slot with junk args
- * (the v4.8.93 regression, caught here by issue-29-tool-translation.mjs).
- *
- * Add new config-scoped tools here as CC's remote config churns. Removing a name
- * is a deliberate act: it means CC genuinely retired the tool, and it should be
- * paired with the capture evidence that says so.
- */
-export const CONFIG_SCOPED_TOOLS = new Set([
-    'TaskCreate',
-    'TaskGet',
-    'TaskList',
-    'TaskUpdate',
-]);
 /** CC's exact tool definitions for the current platform — filtered from the bundled union. */
 export const CC_TOOL_DEFINITIONS = filterToolsForPlatform(TEMPLATE.tools, process.platform);
 /** The UNFILTERED bundled union — every tool the bake knows across platforms
@@ -1738,10 +1672,19 @@ export function buildCCRequest(clientBody, billingTag, cacheControl, identity, o
     // appended its assistant reply locally, dario stripped it from the next
     // request, the model regenerated the same reply, dario stripped that, and
     // the loop never terminated (133 POSTs from a single user prompt).
+    //
+    // Restricted to ASSISTANT turns, which is the only shape this loop was
+    // written for (a thinking-only assistant turn emptied by the strip above).
+    // Popping an empty *user* turn is what the loop must not do: it exposes the
+    // assistant turn behind it and produces the very prefill rejection the loop
+    // exists to prevent (dario#1033). An empty user turn is a malformed client
+    // request either way — leaving it in place lets the upstream name it
+    // accurately ("messages.N: content must contain at least one block")
+    // instead of dario converting it into a misleading prefill error.
     while (messages.length > 0) {
         const last = messages[messages.length - 1];
         const contentEmpty = Array.isArray(last.content) && last.content.length === 0;
-        if (contentEmpty) {
+        if (contentEmpty && last.role === 'assistant') {
             messages.pop();
             continue;
         }

package/dist/live-fingerprint.d.ts

@@ -234,16 +234,82 @@ export declare function promptVariantsOf(t: TemplateData): Record<string, string
  * Variants the live template already has win, so a future per-model live
  * capture supersedes the bake without another change here.
  */
-export declare function withBundledVariants(live: TemplateData): TemplateData;
 /**
- * Load the template synchronously. Prefers the live cache (fresh capture
- * from the user's own CC install) and falls back to the bundled snapshot.
+ * Tools CC only ships on a specific platform. A capture sees only the host it
+ * ran on, so both the bundle and any live capture must be re-unioned against
+ * the other platforms' names before use. Filtered back down to the running
+ * platform at request time by filterToolsForPlatform().
+ *
+ * PowerShell shipped in CC v2.1.116 on Windows; POSIX CC installs do not
+ * advertise it. As of CC v2.1.162 Glob/Grep are the same shape: Windows CC
+ * advertises them, POSIX CC drops them and steers the agent to shell
+ * `find`/`grep` instead. Registering them here filters them to win32 clients
+ * AND keeps a POSIX capture from dropping them out of the union — the v4.8.28
+ * regression, where a Linux runner re-baked the bundle down to 28 tools.
+ * Add new platform-scoped tools here as CC adds them.
+ */
+export declare const PLATFORM_ONLY_TOOLS: Record<string, Set<string>>;
+/**
+ * Tools CC only advertises in an INTERACTIVE session. Captures spawn CC
+ * headlessly (`claude --print -p hi`), and CC v2.1.187 dropped these plan-mode /
+ * clarification tools in `--print` mode — so a fresh headless capture no longer
+ * carries them even though every real interactive CC client still advertises
+ * them. Unlike PLATFORM_ONLY_TOOLS these are NOT platform-filtered: they stay in
+ * the tool set on every host so a client that declares them is always honored.
+ * Add new interactive-only tools here as CC adds them.
+ */
+export declare const INTERACTIVE_ONLY_TOOLS: Set<string>;
+/**
+ * Tools CC advertises only under some runtime configurations. Unlike
+ * INTERACTIVE_ONLY_TOOLS (absent because the capture is headless), these come
+ * and go with CC's REMOTE config for the same capture mode: the 2026-08-11 bake
+ * on CC v2.1.232 captured all four headlessly, and the 2026-08-15 bake on
+ * v2.1.233 captured none of them — while TaskOutput/TaskStop, the rest of the
+ * task subsystem, stayed put. That is the v4.2.1 drift class (same binary,
+ * different wire shape via remote configuration), not a signal that CC retired
+ * the tools.
+ *
+ * Removing a name here is a deliberate act: it means CC genuinely retired the
+ * tool, and it should be paired with the capture evidence that says so.
+ */
+export declare const CONFIG_SCOPED_TOOLS: Set<string>;
+/** Why a given tool was preserved — used for logging at bake time. */
+export type PreservedToolReason = 'platform' | 'interactive' | 'config-scoped';
+/**
+ * Decide whether `name` must be preserved into a capture taken on `platform`,
+ * and say why. The single definition of the superset rule.
+ *
+ * The cost of the two directions is asymmetric, which is what settles it. A
+ * stale entry is INERT: buildCCRequest advertises the intersection of the tool
+ * set with what the CLIENT declared, so an entry no client declares is never
+ * sent. Dropping one is NOT inert — CC_NATIVE_NAMES_UNION is derived from the
+ * loaded template, so a client that does declare the tool stops identity-
+ * mapping, falls into the unmapped round-robin, and has its history tool_use
+ * blocks renamed onto a fallback slot with junk arguments (the v4.8.93
+ * regression).
+ */
+export declare function preservedToolReason(name: string, platform: string): PreservedToolReason | null;
+/**
+ * Re-union `capture.tools` with any tool `fallback` carries that the capture is
+ * required to keep (see preservedToolReason). Returns the merged tool array,
+ * CC's alphabetical wire order restored, plus what was preserved and why.
  *
- * This is intentionally sync and fast — it runs at module init on every
- * dario request handler. The actual capture is async and runs in the
- * background via refreshLiveFingerprintAsync(); its results are written
- * to the cache file and picked up on the next dario startup.
+ * This is the rule the bake has always applied to the previous bundle. It must
+ * apply to a LIVE capture too: `loadTemplate` prefers a fresh live cache, the
+ * cache refreshes on a 24h TTL, and the capture is headless — so without this,
+ * every dario install with CC present degrades its own tool set within a day
+ * of running, and CI never sees it because CI has no live cache (#1035).
  */
+export declare function mergePreservedTools<T extends {
+    name: string;
+}>(captureTools: T[], fallbackTools: T[], platform: string): {
+    tools: T[];
+    preserved: Array<{
+        name: string;
+        reason: PreservedToolReason;
+    }>;
+};
+export declare function withBundledVariants(live: TemplateData): TemplateData;
 export declare function loadTemplate(_options?: {
     silent?: boolean;
 }): TemplateData;

package/dist/live-fingerprint.js

@@ -167,6 +167,114 @@ export function promptVariantsOf(t) {
  * Variants the live template already has win, so a future per-model live
  * capture supersedes the bake without another change here.
  */
+/**
+ * Tools CC only ships on a specific platform. A capture sees only the host it
+ * ran on, so both the bundle and any live capture must be re-unioned against
+ * the other platforms' names before use. Filtered back down to the running
+ * platform at request time by filterToolsForPlatform().
+ *
+ * PowerShell shipped in CC v2.1.116 on Windows; POSIX CC installs do not
+ * advertise it. As of CC v2.1.162 Glob/Grep are the same shape: Windows CC
+ * advertises them, POSIX CC drops them and steers the agent to shell
+ * `find`/`grep` instead. Registering them here filters them to win32 clients
+ * AND keeps a POSIX capture from dropping them out of the union — the v4.8.28
+ * regression, where a Linux runner re-baked the bundle down to 28 tools.
+ * Add new platform-scoped tools here as CC adds them.
+ */
+export const PLATFORM_ONLY_TOOLS = {
+    win32: new Set(['PowerShell', 'Glob', 'Grep']),
+};
+/**
+ * Tools CC only advertises in an INTERACTIVE session. Captures spawn CC
+ * headlessly (`claude --print -p hi`), and CC v2.1.187 dropped these plan-mode /
+ * clarification tools in `--print` mode — so a fresh headless capture no longer
+ * carries them even though every real interactive CC client still advertises
+ * them. Unlike PLATFORM_ONLY_TOOLS these are NOT platform-filtered: they stay in
+ * the tool set on every host so a client that declares them is always honored.
+ * Add new interactive-only tools here as CC adds them.
+ */
+export const INTERACTIVE_ONLY_TOOLS = new Set([
+    'AskUserQuestion',
+    'EnterPlanMode',
+    'ExitPlanMode',
+]);
+/**
+ * Tools CC advertises only under some runtime configurations. Unlike
+ * INTERACTIVE_ONLY_TOOLS (absent because the capture is headless), these come
+ * and go with CC's REMOTE config for the same capture mode: the 2026-08-11 bake
+ * on CC v2.1.232 captured all four headlessly, and the 2026-08-15 bake on
+ * v2.1.233 captured none of them — while TaskOutput/TaskStop, the rest of the
+ * task subsystem, stayed put. That is the v4.2.1 drift class (same binary,
+ * different wire shape via remote configuration), not a signal that CC retired
+ * the tools.
+ *
+ * Removing a name here is a deliberate act: it means CC genuinely retired the
+ * tool, and it should be paired with the capture evidence that says so.
+ */
+export const CONFIG_SCOPED_TOOLS = new Set([
+    'TaskCreate',
+    'TaskGet',
+    'TaskList',
+    'TaskUpdate',
+]);
+/**
+ * Decide whether `name` must be preserved into a capture taken on `platform`,
+ * and say why. The single definition of the superset rule.
+ *
+ * The cost of the two directions is asymmetric, which is what settles it. A
+ * stale entry is INERT: buildCCRequest advertises the intersection of the tool
+ * set with what the CLIENT declared, so an entry no client declares is never
+ * sent. Dropping one is NOT inert — CC_NATIVE_NAMES_UNION is derived from the
+ * loaded template, so a client that does declare the tool stops identity-
+ * mapping, falls into the unmapped round-robin, and has its history tool_use
+ * blocks renamed onto a fallback slot with junk arguments (the v4.8.93
+ * regression).
+ */
+export function preservedToolReason(name, platform) {
+    for (const [plat, names] of Object.entries(PLATFORM_ONLY_TOOLS)) {
+        if (names.has(name) && plat !== platform)
+            return 'platform';
+    }
+    if (INTERACTIVE_ONLY_TOOLS.has(name))
+        return 'interactive';
+    if (CONFIG_SCOPED_TOOLS.has(name))
+        return 'config-scoped';
+    return null;
+}
+/**
+ * Re-union `capture.tools` with any tool `fallback` carries that the capture is
+ * required to keep (see preservedToolReason). Returns the merged tool array,
+ * CC's alphabetical wire order restored, plus what was preserved and why.
+ *
+ * This is the rule the bake has always applied to the previous bundle. It must
+ * apply to a LIVE capture too: `loadTemplate` prefers a fresh live cache, the
+ * cache refreshes on a 24h TTL, and the capture is headless — so without this,
+ * every dario install with CC present degrades its own tool set within a day
+ * of running, and CI never sees it because CI has no live cache (#1035).
+ */
+export function mergePreservedTools(captureTools, fallbackTools, platform) {
+    const have = new Set(captureTools.map((t) => t.name));
+    const preserved = [];
+    const additions = [];
+    for (const tool of fallbackTools) {
+        if (have.has(tool.name))
+            continue;
+        const reason = preservedToolReason(tool.name, platform);
+        if (!reason)
+            continue;
+        additions.push(tool);
+        preserved.push({ name: tool.name, reason });
+        have.add(tool.name);
+    }
+    if (additions.length === 0)
+        return { tools: captureTools, preserved };
+    // CC sends tools alphabetically by name — sort after merge so preserved tools
+    // insert at their natural position rather than appending at the end.
+    return {
+        tools: [...captureTools, ...additions].sort((a, b) => a.name.localeCompare(b.name)),
+        preserved,
+    };
+}
 export function withBundledVariants(live) {
     let bundled;
     try {
@@ -217,12 +325,40 @@ const LIVE_TTL_MS = 24 * 60 * 60 * 1000; // re-extract once a day
  * background via refreshLiveFingerprintAsync(); its results are written
  * to the cache file and picked up on the next dario startup.
  */
+/**
+ * Bring a live capture up to the superset the rest of the codebase assumes:
+ * merge back any preserved tool the bundle has and the capture lacks, then
+ * re-derive `tool_names`.
+ *
+ * `tool_names === tools.map(t => t.name)` is the contract everywhere —
+ * scrubTemplate() sets it from `tools`, and so does the capture path. The bake
+ * learned the hard way that a merge which mutates `tools` without re-deriving
+ * the list ships an artifact whose two tool lists disagree; do not repeat it
+ * here (#1035).
+ */
+function withPreservedTools(live, options) {
+    let bundled;
+    try {
+        bundled = loadBundledTemplate({ silent: true });
+    }
+    catch {
+        return live; // bundle unreadable — the capture is still better than throwing
+    }
+    const { tools, preserved } = mergePreservedTools(live.tools, bundled.tools, process.platform);
+    if (preserved.length === 0)
+        return live;
+    if (!options?.silent) {
+        const byReason = preserved.map((p) => `${p.name} (${p.reason})`).join(', ');
+        console.log(`[dario] live template: restored ${preserved.length} tool${preserved.length === 1 ? '' : 's'} the capture omitted: ${byReason}`);
+    }
+    return { ...live, tools, tool_names: tools.map((t) => t.name) };
+}
 export function loadTemplate(_options) {
     const cached = readLiveCache();
     if (cached) {
         const age = Date.now() - new Date(cached._captured).getTime();
         if (age < LIVE_TTL_MS) {
-            return withBundledVariants(cached);
+            return withPreservedTools(withBundledVariants(cached), _options);
         }
         // Stale cache: prefer whichever of the live cache and the bundled
         // snapshot was captured more recently — do NOT blindly keep the cache.
@@ -236,7 +372,7 @@ export function loadTemplate(_options) {
         const bundled = loadBundledTemplate(_options);
         const cachedAt = new Date(cached._captured).getTime();
         const bundledAt = new Date(bundled._captured).getTime();
-        return Number.isFinite(bundledAt) && bundledAt > cachedAt ? bundled : withBundledVariants(cached);
+        return Number.isFinite(bundledAt) && bundledAt > cachedAt ? bundled : withPreservedTools(withBundledVariants(cached), _options);
     }
     return loadBundledTemplate(_options);
 }

package/dist/proxy.js

@@ -658,6 +658,12 @@ export function sanitizeMessages(body, preserveTags) {
     if (!messages)
         return;
     const patterns = orchestrationPatternsFor(preserveTags);
+    // Snapshot the tail turn before scrubbing. If the scrub empties it and the
+    // drop below would expose an assistant turn, we put the original content
+    // back rather than ship a prefill (dario#1033) — see the guard after the
+    // filter for the reasoning.
+    const tail = messages.length > 0 ? messages[messages.length - 1] : undefined;
+    const tailContentBeforeScrub = tail ? tail.content : undefined;
     for (const msg of messages) {
         if (typeof msg.content === 'string') {
             msg.content = sanitizeContent(msg.content, patterns);
@@ -691,13 +697,48 @@ export function sanitizeMessages(body, preserveTags) {
     // The message carried nothing for the model, so removing it is the same
     // decision the block filter already made, applied one level up. String
     // content scrubbed to '' is the same case in its other shape.
-    body.messages = messages.filter((m) => {
+    const kept = messages.filter((m) => {
         if (Array.isArray(m.content))
             return m.content.length > 0;
         if (typeof m.content === 'string')
             return m.content !== '';
         return true;
     });
+    // Invariant: the scrub must never turn a request that ended on a USER turn
+    // into one that ends on an ASSISTANT turn. Anthropic reads a trailing
+    // assistant turn as a prefill ("continue from this text") and Opus 4.6 under
+    // adaptive thinking + the claude-code beta rejects it outright:
+    //   400 "This model does not support assistant message prefill.
+    //        The conversation must end with a user message."
+    //
+    // CC emits standalone `<system-reminder>` / `<task_metadata>` user turns —
+    // notably right after a Task (sub-agent) result is folded back into the
+    // parent transcript. Both tags are in ORCHESTRATION_TAG_NAMES, so that turn
+    // scrubs to empty, the filter above drops it, and a valid CC request leaves
+    // as a prefill (dario#1033).
+    //
+    // The fix restores the turn's PRE-SCRUB content instead of dropping it. The
+    // orchestration tag survives in this one position only, which is the right
+    // trade in both directions: for a CC client the tag is CC's own injection,
+    // so keeping it is *more* wire-faithful, not less; for a non-CC client a
+    // lone tag as the final turn is the actual prompt, and forwarding it beats
+    // a hard 400. Every other position still scrubs exactly as before.
+    const tailWasDropped = tail !== undefined && kept[kept.length - 1] !== tail;
+    const tailHadContent = Array.isArray(tailContentBeforeScrub)
+        ? tailContentBeforeScrub.length > 0
+        : typeof tailContentBeforeScrub === 'string'
+            ? tailContentBeforeScrub !== ''
+            : tailContentBeforeScrub != null;
+    if (tail !== undefined &&
+        tailWasDropped &&
+        tail.role === 'user' &&
+        tailHadContent &&
+        kept.length > 0 &&
+        kept[kept.length - 1].role === 'assistant') {
+        tail.content = tailContentBeforeScrub;
+        kept.push(tail);
+    }
+    body.messages = kept;
 }
 /**
  * Scrub non-Claude-Code fields and normalize field ordering.

package/package.json

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