@ashlr/hub 3.8.0 → 3.9.0

package/dist/core/universe/builtins/preparation/preparation-verification-fixtures.mjs

@@ -1951,13 +1951,20 @@ var init_model_catalog = __esm({
       // minEffort 2: measured ~590 s/task against 53-381 s for the previous
       // generation. Consistent, but too slow to be the pick for trivial work —
       // `maxEffort: 1` queries keep falling through to the lighter entries.
+      //
+      // NO 'long-context' (Verse 3.9). The tag is `…-ctx64k`: its Modelfile pins
+      // `num_ctx 65536`, Ollama serves it at exactly 65536 (`n_ctx_slot = 65536`
+      // in every server log), and on the llama-server lane each slot gets 65536
+      // too. That is below the >=100k the capability promises, so tagging it sent
+      // long-context work to a model that would overflow. The architecture's
+      // 262144 is reachable only through a differently pinned tag.
       {
         id: `local-coder:${DEFAULT_LOCAL_MODEL_TAG}`,
         engine: "local-coder",
         tier: "mid",
         costPerMTokIn: 0,
         costPerMTokOut: 0,
-        capabilities: ["coder", "reasoning", "long-context"],
+        capabilities: ["coder", "reasoning"],
         minEffort: 2
       },
       // -- Local -- small (catch-all tiny model for trivial tasks) --------------

package/dist/core/verse/adapters/claude.d.ts

@@ -11,6 +11,25 @@
  * llama-server lane — the normalising proxy in front of llama-server. The
  * adapter does not choose; it forwards the choice `seats.ts` already made.
  *
+ * V3.9 context flags (docs/VERSE-CONTEXT.md). Every flag and env var below was
+ * checked on BOTH binaries a seat can be pinned to — `claude --help` on
+ * 2.1.257 and 2.1.280 lists `--autocompact <auto|tokens>`,
+ * `--append-system-prompt <prompt>`, `--add-dir <directories...>` and
+ * `--exclude-dynamic-system-prompt-sections`, and both binaries' strings
+ * contain `CLAUDE_CODE_MAX_CONTEXT_TOKENS`:
+ *
+ *  - claude seats, 1M-native models: `--autocompact 400000` in standard mode,
+ *    `--autocompact auto` in expansive (context-math `claudeAutocompactFlag`).
+ *    200k models get no flag — they already compact near 167k natively.
+ *  - local seats: `CLAUDE_CODE_MAX_CONTEXT_TOKENS=<the session's window>` so
+ *    the CLI compacts before Ollama truncates (without it the CLI assumes its
+ *    200k unknown-model default and never compacts a 64k runner), plus
+ *    `--exclude-dynamic-system-prompt-sections` so the per-launch git status
+ *    and env block stop invalidating the local runner's prefix cache.
+ *  - shared project memory (launch.memory): `--add-dir <dir>` when writable and
+ *    `--append-system-prompt=<block>`, the SAME snapshotted block every turn so
+ *    the prompt prefix stays byte-identical.
+ *
  * Parse: claude's stream-json is JSONL where streaming deltas are wrapped as
  * `{type:'stream_event', event:{...Anthropic Messages wire event}}` and whole
  * messages arrive as `{type:'assistant'|'user', message:{content:[...]}}`,
@@ -21,17 +40,45 @@ import type { VerseAdapter, VerseTurnParser } from './index.js';
 type JsonObject = Record<string, unknown>;
 /** Parse one JSONL line into an object, or null for anything that is not one. */
 export declare function parseJsonObjectLine(line: string): JsonObject | null;
+/**
+ * The context window the CLI reported for this turn's model in
+ * `result.modelUsage` — the same number it compacts against, computed at
+ * result time, so it already reflects a long-context credit clamp (1M → 200k)
+ * or grok's mid-session window upgrade.
+ *
+ * Which row: `modelUsage` is keyed per model and a turn can touch several
+ * (claude runs side calls on Haiku). So, in order:
+ *   1. the row whose key IS the turn's model (canonicalised — a record naming
+ *      the retired alias `claude-opus-5.5` still finds `claude-opus-5-5`);
+ *   2. the same comparison with a `[1m]` suffix stripped from both sides;
+ *   3. the ONLY row carrying a numeric `contextWindow` — grok's key can differ
+ *      from the CLI id (`grok-4.6-build` for `grok-4.6`) and grok puts the
+ *      window on the current model's row alone.
+ * Anything else (several windowed rows, none matching) is ambiguous and yields
+ * null: an unknown window is shown as unknown, never guessed.
+ */
+export declare function runtimeContextWindow(modelUsage: unknown, model: string | null): number | null;
 /**
  * Shared parser for the Anthropic Messages wire format. Accepts:
  *   - bare wire events (`message_start`, `content_block_start`, `content_block_delta`,
  *     `content_block_stop`, `message_delta`, `message_stop`) — grok's streaming-messages-json;
  *   - the same events wrapped in claude's `{type:'stream_event', event:{...}}`;
- *   - claude's whole-message envelopes `assistant` / `user` and the terminal `result`;
- *   - `system` (`init` captures session_id).
+ *   - claude's whole-message envelopes `assistant` / `user` and the terminal `result`
+ *     (whose `modelUsage` carries the CLI's context window for the turn);
+ *   - `system` (`init` captures session_id and model; `compact_boundary`
+ *     becomes a `compaction` event).
  *
  * A text/tool_use/thinking block can arrive twice — once via the streamed
  * content_block_* events and again inside an `assistant` envelope — so block
  * events are deduplicated by content within a turn.
+ *
+ * Usage is deduplicated the same way, by API call. With partial messages on,
+ * ONE call is reported by `message_start` + `message_delta` AND by one
+ * `assistant` envelope per content block. Summing every report (as this parser
+ * once did) counted a two-block call three times; the turn total only looked
+ * right because the terminal `result` replaced it. Each call is keyed by its
+ * message id and its readings are merged, so the fallback total is right too
+ * when a process dies before `result`.
  */
 /**
  * Shared by the claude/local and grok adapters — both speak the Anthropic wire

package/dist/core/verse/adapters/claude.js

@@ -11,13 +11,34 @@
  * llama-server lane — the normalising proxy in front of llama-server. The
  * adapter does not choose; it forwards the choice `seats.ts` already made.
  *
+ * V3.9 context flags (docs/VERSE-CONTEXT.md). Every flag and env var below was
+ * checked on BOTH binaries a seat can be pinned to — `claude --help` on
+ * 2.1.257 and 2.1.280 lists `--autocompact <auto|tokens>`,
+ * `--append-system-prompt <prompt>`, `--add-dir <directories...>` and
+ * `--exclude-dynamic-system-prompt-sections`, and both binaries' strings
+ * contain `CLAUDE_CODE_MAX_CONTEXT_TOKENS`:
+ *
+ *  - claude seats, 1M-native models: `--autocompact 400000` in standard mode,
+ *    `--autocompact auto` in expansive (context-math `claudeAutocompactFlag`).
+ *    200k models get no flag — they already compact near 167k natively.
+ *  - local seats: `CLAUDE_CODE_MAX_CONTEXT_TOKENS=<the session's window>` so
+ *    the CLI compacts before Ollama truncates (without it the CLI assumes its
+ *    200k unknown-model default and never compacts a 64k runner), plus
+ *    `--exclude-dynamic-system-prompt-sections` so the per-launch git status
+ *    and env block stop invalidating the local runner's prefix cache.
+ *  - shared project memory (launch.memory): `--add-dir <dir>` when writable and
+ *    `--append-system-prompt=<block>`, the SAME snapshotted block every turn so
+ *    the prompt prefix stays byte-identical.
+ *
  * Parse: claude's stream-json is JSONL where streaming deltas are wrapped as
  * `{type:'stream_event', event:{...Anthropic Messages wire event}}` and whole
  * messages arrive as `{type:'assistant'|'user', message:{content:[...]}}`,
  * followed by `{type:'result', ...}`. The wire-format machinery is shared with
  * the grok adapter, which emits the same events without the wrapper.
  */
-import { verseSessionRoots } from '../types.js';
+import { canonicalModelId, claudeAutocompactFlag, hasExpansiveMode, } from '../context-math.js';
+import { legacyModelOptionFallback } from '../model-windows.js';
+import { VERSE_DEFAULT_CONTEXT_WINDOWS, verseSessionRoots, } from '../types.js';
 function isObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -27,6 +48,12 @@ function num(value) {
 function str(value) {
     return typeof value === 'string' ? value : '';
 }
+function positiveInt(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? Math.floor(value) : null;
+}
+function nonNegativeInt(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? Math.floor(value) : null;
+}
 /** Parse one JSONL line into an object, or null for anything that is not one. */
 export function parseJsonObjectLine(line) {
     const trimmed = line.trim();
@@ -55,15 +82,112 @@ function readAnthropicUsage(usage) {
         cacheCreation: num(usage['cache_creation_input_tokens']),
     };
 }
-function toVerseUsage(totals, last) {
+const ZERO_USAGE = { input: 0, output: 0, cacheRead: 0, cacheCreation: 0 };
+function addUsage(a, b) {
+    return {
+        input: a.input + b.input,
+        output: a.output + b.output,
+        cacheRead: a.cacheRead + b.cacheRead,
+        cacheCreation: a.cacheCreation + b.cacheCreation,
+    };
+}
+/**
+ * Two readings of the SAME API call. Every bucket is either fixed for the call
+ * (the prompt side, known at `message_start`) or cumulative within it (output,
+ * which `message_delta` and each `assistant` envelope re-report as it grows),
+ * so the per-bucket maximum is the call's final figure however many times and
+ * in whatever order it was reported.
+ */
+function maxUsage(a, b) {
+    return {
+        input: Math.max(a.input, b.input),
+        output: Math.max(a.output, b.output),
+        cacheRead: Math.max(a.cacheRead, b.cacheRead),
+        cacheCreation: Math.max(a.cacheCreation, b.cacheCreation),
+    };
+}
+function isZeroUsage(u) {
+    return u.input === 0 && u.output === 0 && u.cacheRead === 0 && u.cacheCreation === 0;
+}
+function toVerseUsage(totals, contextTokens, contextWindow) {
     return {
         inputTokens: totals.input,
         outputTokens: totals.output,
         cacheReadTokens: totals.cacheRead,
         cacheCreationTokens: totals.cacheCreation,
-        // Live context occupancy = prompt size of the most recent API call.
-        contextTokens: last.input + last.cacheRead + last.cacheCreation,
-        contextWindow: null,
+        // Live context occupancy = prompt size of the most recent API call. NOT
+        // clamped to the window: a reading above it is information.
+        contextTokens,
+        // The CLI's own figure for THIS turn (result.modelUsage), else null. The
+        // engine decides whether it wins (it ignores it on engine=local, where
+        // Verse set the window itself through CLAUDE_CODE_MAX_CONTEXT_TOKENS).
+        contextWindow,
+    };
+}
+/** `claude-opus-4-8[1m]` → `claude-opus-4-8`: the suffix is a request for the 1M window, not a different model. */
+function stripOneMillionSuffix(id) {
+    return id.replace(/\[1m\]$/i, '');
+}
+/**
+ * The context window the CLI reported for this turn's model in
+ * `result.modelUsage` — the same number it compacts against, computed at
+ * result time, so it already reflects a long-context credit clamp (1M → 200k)
+ * or grok's mid-session window upgrade.
+ *
+ * Which row: `modelUsage` is keyed per model and a turn can touch several
+ * (claude runs side calls on Haiku). So, in order:
+ *   1. the row whose key IS the turn's model (canonicalised — a record naming
+ *      the retired alias `claude-opus-5.5` still finds `claude-opus-5-5`);
+ *   2. the same comparison with a `[1m]` suffix stripped from both sides;
+ *   3. the ONLY row carrying a numeric `contextWindow` — grok's key can differ
+ *      from the CLI id (`grok-4.6-build` for `grok-4.6`) and grok puts the
+ *      window on the current model's row alone.
+ * Anything else (several windowed rows, none matching) is ambiguous and yields
+ * null: an unknown window is shown as unknown, never guessed.
+ */
+export function runtimeContextWindow(modelUsage, model) {
+    if (!isObject(modelUsage))
+        return null;
+    const rows = Object.entries(modelUsage).filter((entry) => isObject(entry[1]));
+    if (rows.length === 0)
+        return null;
+    if (model) {
+        const wanted = canonicalModelId(model);
+        const exact = rows.find(([key]) => canonicalModelId(key) === wanted);
+        const exactWindow = exact ? positiveInt(exact[1]['contextWindow']) : null;
+        if (exactWindow !== null)
+            return exactWindow;
+        const wantedBase = stripOneMillionSuffix(wanted);
+        const stripped = rows.find(([key]) => stripOneMillionSuffix(canonicalModelId(key)) === wantedBase);
+        const strippedWindow = stripped ? positiveInt(stripped[1]['contextWindow']) : null;
+        if (strippedWindow !== null)
+            return strippedWindow;
+    }
+    const windowed = rows.map(([, row]) => positiveInt(row['contextWindow'])).filter((w) => w !== null);
+    return windowed.length === 1 ? windowed[0] : null;
+}
+/**
+ * `system/compact_boundary` → a `compaction` event. Both CLIs emit it (claude
+ * as `compact_metadata:{trigger, pre_tokens, post_tokens?, duration_ms?}`;
+ * grok documents the same line and ships the same field names). The camelCase
+ * spelling Claude Code uses in its own transcripts is accepted too, so a
+ * transcript-shaped line is never silently lost. Counts the CLI omitted stay
+ * null — the UI then says "compacted" without inventing a size.
+ */
+function compactionFrom(turnId, ev) {
+    const meta = isObject(ev['compact_metadata'])
+        ? ev['compact_metadata']
+        : isObject(ev['compactMetadata']) ? ev['compactMetadata'] : {};
+    const pick = (snake, camel) => nonNegativeInt(meta[snake]) ?? nonNegativeInt(meta[camel]);
+    return {
+        type: 'compaction',
+        turnId,
+        // Only `manual` is distinguishable from the default; a headless turn that
+        // compacted without being asked to did so automatically.
+        trigger: meta['trigger'] === 'manual' ? 'manual' : 'auto',
+        preTokens: pick('pre_tokens', 'preTokens'),
+        postTokens: pick('post_tokens', 'postTokens'),
+        durationMs: pick('duration_ms', 'durationMs'),
     };
 }
 /** Render a tool_result `content` field (string or content-block array) as text. */
@@ -91,12 +215,22 @@ function toolResultText(content) {
  *   - bare wire events (`message_start`, `content_block_start`, `content_block_delta`,
  *     `content_block_stop`, `message_delta`, `message_stop`) — grok's streaming-messages-json;
  *   - the same events wrapped in claude's `{type:'stream_event', event:{...}}`;
- *   - claude's whole-message envelopes `assistant` / `user` and the terminal `result`;
- *   - `system` (`init` captures session_id).
+ *   - claude's whole-message envelopes `assistant` / `user` and the terminal `result`
+ *     (whose `modelUsage` carries the CLI's context window for the turn);
+ *   - `system` (`init` captures session_id and model; `compact_boundary`
+ *     becomes a `compaction` event).
  *
  * A text/tool_use/thinking block can arrive twice — once via the streamed
  * content_block_* events and again inside an `assistant` envelope — so block
  * events are deduplicated by content within a turn.
+ *
+ * Usage is deduplicated the same way, by API call. With partial messages on,
+ * ONE call is reported by `message_start` + `message_delta` AND by one
+ * `assistant` envelope per content block. Summing every report (as this parser
+ * once did) counted a two-block call three times; the turn total only looked
+ * right because the terminal `result` replaced it. Each call is keyed by its
+ * message id and its readings are merged, so the fallback total is right too
+ * when a process dies before `result`.
  */
 /**
  * Shared by the claude/local and grok adapters — both speak the Anthropic wire
@@ -106,29 +240,54 @@ function toolResultText(content) {
  */
 export function createAnthropicStreamParser(turnId, engineLabel = 'claude') {
     let nativeId = null;
+    /** The model the CLI says it runs (`system/init.model`, else the latest assistant frame's). */
+    let initModel = null;
+    let frameModel = null;
     const open = new Map();
     const emittedText = new Set();
     const emittedThinking = new Set();
     const emittedToolUse = new Set();
     const emittedToolResult = new Set();
-    let lastCallUsage = null;
-    let turnTotals = { input: 0, output: 0, cacheRead: 0, cacheCreation: 0 };
+    /**
+     * One entry per API call, in the order the calls STARTED (Map keeps first
+     * insertion order on update), so the last entry is the latest call — whose
+     * prompt size is the live context occupancy.
+     */
+    const calls = new Map();
+    /** The call the wire stream is currently inside (set by `message_start`). */
+    let currentCall = null;
+    let syntheticCalls = 0;
     let resultTotals = null;
+    let runtimeWindow = null;
+    /**
+     * `post_tokens` of a compaction that happened AFTER the latest call. The
+     * latest call's prompt size predates it, so the usage event reports the
+     * CLI's post-compaction figure instead (a manual `/compact` turn makes no
+     * further call). Cleared as soon as another call starts.
+     */
+    let postCompactionTokens = null;
     let usageEmitted = false;
-    // message_start carries input-side usage, message_delta the output side; they
-    // describe the same API call, so merge them before rolling into the totals.
-    let pendingCall = null;
-    function commitPendingCall() {
-        if (!pendingCall)
-            return;
-        lastCallUsage = pendingCall;
-        turnTotals = {
-            input: turnTotals.input + pendingCall.input,
-            output: turnTotals.output + pendingCall.output,
-            cacheRead: turnTotals.cacheRead + pendingCall.cacheRead,
-            cacheCreation: turnTotals.cacheCreation + pendingCall.cacheCreation,
-        };
-        pendingCall = null;
+    function syntheticKey(kind) {
+        syntheticCalls += 1;
+        return `${kind}#${syntheticCalls}`;
+    }
+    function recordCall(key, usage) {
+        const previous = calls.get(key);
+        if (!previous)
+            postCompactionTokens = null;
+        calls.set(key, previous ? maxUsage(previous, usage) : usage);
+    }
+    function lastCall() {
+        let last = null;
+        for (const usage of calls.values())
+            last = usage;
+        return last;
+    }
+    function callTotals() {
+        let totals = ZERO_USAGE;
+        for (const usage of calls.values())
+            totals = addUsage(totals, usage);
+        return totals;
     }
     function emitText(out, text) {
         if (!text || emittedText.has(text))
@@ -193,23 +352,30 @@ export function createAnthropicStreamParser(turnId, engineLabel = 'claude') {
     function emitUsage(out) {
         if (usageEmitted)
             return;
-        commitPendingCall();
-        const totals = resultTotals ?? turnTotals;
-        const last = lastCallUsage ?? resultTotals;
-        if (!last)
+        const summed = callTotals();
+        // `result.usage` is the CLI's own turn total and wins — except when it is
+        // all zeros while calls were observed: grok documents an all-zero result
+        // usage as "unknown", not "free", so the observed calls are the better truth.
+        const totals = resultTotals && !(isZeroUsage(resultTotals) && !isZeroUsage(summed)) ? resultTotals : summed;
+        const last = lastCall() ?? resultTotals;
+        if (!last && postCompactionTokens === null)
             return;
         usageEmitted = true;
-        out.push({ type: 'usage', turnId, usage: toVerseUsage(totals, last) });
+        const contextTokens = postCompactionTokens
+            ?? (last ? last.input + last.cacheRead + last.cacheCreation : 0);
+        out.push({ type: 'usage', turnId, usage: toVerseUsage(totals, contextTokens, runtimeWindow) });
     }
     function handleWireEvent(out, ev) {
         const type = str(ev['type']);
         switch (type) {
             case 'message_start': {
-                commitPendingCall();
                 const message = isObject(ev['message']) ? ev['message'] : null;
+                currentCall = str(message?.['id']) || syntheticKey('wire');
+                if (typeof message?.['model'] === 'string' && message['model'])
+                    frameModel = message['model'];
                 const usage = readAnthropicUsage(message?.['usage']);
                 if (usage)
-                    pendingCall = usage;
+                    recordCall(currentCall, usage);
                 open.clear();
                 return;
             }
@@ -258,24 +424,17 @@ export function createAnthropicStreamParser(turnId, engineLabel = 'claude') {
             case 'message_delta': {
                 const usage = readAnthropicUsage(ev['usage']);
                 if (usage) {
-                    if (pendingCall) {
-                        pendingCall = {
-                            input: usage.input || pendingCall.input,
-                            output: usage.output || pendingCall.output,
-                            cacheRead: usage.cacheRead || pendingCall.cacheRead,
-                            cacheCreation: usage.cacheCreation || pendingCall.cacheCreation,
-                        };
-                    }
-                    else {
-                        pendingCall = usage;
-                    }
+                    if (!currentCall)
+                        currentCall = syntheticKey('wire');
+                    recordCall(currentCall, usage);
                 }
                 return;
             }
             case 'message_stop': {
                 for (const index of [...open.keys()])
                     closeBlock(out, index);
-                commitPendingCall();
+                // `currentCall` stays set: an id-less `assistant` envelope that follows
+                // describes this same call, not a new one.
                 return;
             }
             default:
@@ -286,8 +445,18 @@ export function createAnthropicStreamParser(turnId, engineLabel = 'claude') {
         const type = str(ev['type']);
         switch (type) {
             case 'system': {
-                if (ev['subtype'] === 'init' && typeof ev['session_id'] === 'string')
-                    nativeId = ev['session_id'];
+                const subtype = ev['subtype'];
+                if (subtype === 'init') {
+                    if (typeof ev['session_id'] === 'string')
+                        nativeId = ev['session_id'];
+                    if (typeof ev['model'] === 'string' && ev['model'])
+                        initModel = ev['model'];
+                }
+                else if (subtype === 'compact_boundary') {
+                    const compaction = compactionFrom(turnId, ev);
+                    postCompactionTokens = compaction.postTokens;
+                    out.push(compaction);
+                }
                 return true;
             }
             case 'stream_event': {
@@ -301,16 +470,12 @@ export function createAnthropicStreamParser(turnId, engineLabel = 'claude') {
                 if (!message)
                     return true;
                 if (type === 'assistant') {
+                    if (typeof message['model'] === 'string' && message['model'])
+                        frameModel = message['model'];
                     const usage = readAnthropicUsage(message['usage']);
                     if (usage) {
-                        pendingCall = null;
-                        lastCallUsage = usage;
-                        turnTotals = {
-                            input: turnTotals.input + usage.input,
-                            output: turnTotals.output + usage.output,
-                            cacheRead: turnTotals.cacheRead + usage.cacheRead,
-                            cacheCreation: turnTotals.cacheCreation + usage.cacheCreation,
-                        };
+                        const key = str(message['id']) || currentCall || syntheticKey('envelope');
+                        recordCall(key, usage);
                     }
                 }
                 const content = message['content'];
@@ -331,6 +496,7 @@ export function createAnthropicStreamParser(turnId, engineLabel = 'claude') {
                 const usage = readAnthropicUsage(ev['usage']);
                 if (usage)
                     resultTotals = usage;
+                runtimeWindow = runtimeContextWindow(ev['modelUsage'], initModel ?? frameModel);
                 const subtype = str(ev['subtype']);
                 if (subtype && subtype !== 'success') {
                     const detail = str(ev['error']) || str(ev['result']) || subtype;
@@ -385,14 +551,94 @@ export function createAnthropicStreamParser(turnId, engineLabel = 'claude') {
 export function anthropicEnvBaseUrl(baseUrl) {
     return baseUrl.replace(/\/+$/, '').replace(/\/v1$/, '');
 }
+// ---------------------------------------------------------------------------
+// Launch helpers (pure: they read only the session and its launch snapshot)
+// ---------------------------------------------------------------------------
+/** The seat option for the session's model — exact id first, then canonical id (alias ↔ real id). */
+function seatModelOption(session, launch) {
+    const models = Array.isArray(launch.seat?.models) ? launch.seat.models : [];
+    const exact = models.find((m) => m.id === session.model);
+    if (exact)
+        return exact;
+    const wanted = canonicalModelId(session.model);
+    return models.find((m) => canonicalModelId(m.id) === wanted) ?? null;
+}
+/**
+ * The option whose budgets decide a CLAUDE seat's `--autocompact` flag.
+ *
+ * Normally the launch snapshot's own option. A snapshot written before 3.9
+ * carries only the old flat 200k window and no budgets, so its model is looked
+ * up in the verified per-model table (model-windows.ts) instead — through
+ * `legacyModelOptionFallback`, the SAME helper the engine's
+ * `effectiveModelOption` calls, so the compaction point the engine records is
+ * exactly the one this flag tells the CLI. A model neither knows keeps its
+ * snapshot option (and so, lacking an expansive budget, gets no flag: the
+ * CLI's own default applies).
+ *
+ * The MODE is the session's. A pre-3.9 record has none on disk; the engine
+ * materialises one (`expansive` for a 1M model — what 3.8 ran) before it ever
+ * builds a launch, so this adapter never has to guess what "absent" meant.
+ */
+function claudeBudgetOption(session, launch) {
+    return legacyModelOptionFallback('claude', session.model, seatModelOption(session, launch));
+}
+/**
+ * `--autocompact` for a claude seat, or nothing.
+ *
+ * Only 1M-native models (the ones with a real expansive budget) are steered:
+ * standard mode caps compaction at `claudeAutocompactFlag` (400k), expansive
+ * passes `auto` — explicitly, so a stray `autoCompactWindow` in the seat's own
+ * settings cannot silently shrink a budget the operator chose. A 200k model
+ * gets no flag at all; the CLI's `auto` already is its budget.
+ */
+function autocompactArgs(session, launch) {
+    if (session.engine !== 'claude')
+        return [];
+    const option = claudeBudgetOption(session, launch);
+    if (!hasExpansiveMode(option))
+        return [];
+    const flag = claudeAutocompactFlag(option, session.contextMode ?? 'standard');
+    return ['--autocompact', flag === null ? 'auto' : String(flag)];
+}
+/**
+ * The window a LOCAL seat's CLI is told it has. The session's own window first
+ * (set from the seat's resolved num_ctx at creation, and never replaced by a
+ * runtime reading on engine=local), then the launch snapshot's option, then the
+ * seat's, then the named default the local seats pin.
+ */
+function localContextWindow(session, launch) {
+    return positiveInt(session.usage?.contextWindow)
+        ?? positiveInt(seatModelOption(session, launch)?.contextWindow)
+        ?? positiveInt(launch.seat?.contextWindow)
+        ?? VERSE_DEFAULT_CONTEXT_WINDOWS['local'];
+}
+/** A launch record's memory snapshot, if it is well-formed; anything else is treated as "memory off". */
+function launchMemory(launch) {
+    const memory = launch.memory;
+    if (!isObject(memory))
+        return null;
+    const dir = memory['dir'];
+    const block = memory['block'];
+    if (typeof dir !== 'string' || !dir.startsWith('/') || typeof block !== 'string' || block.trim().length === 0)
+        return null;
+    return { dir, block, writable: memory['writable'] === true };
+}
 function buildClaudeLaunch(session, text, launch) {
     if (!session.nativeSessionId) {
         throw new Error('claude session is missing its native session id');
     }
-    const prefix = session.engine === 'local' || !launch.launcher ? ['claude'] : [...launch.launcher];
+    const isLocal = session.engine === 'local';
+    const prefix = isLocal || !launch.launcher ? ['claude'] : [...launch.launcher];
     // Workspace roots beyond the primary. `verseSessionRoots` puts the primary
     // first and it is already the cwd, so only the tail needs a flag.
     const extraRoots = verseSessionRoots(session).slice(1);
+    const memory = launchMemory(launch);
+    // The memory directory is granted only when the snapshot says this seat may
+    // WRITE it: `--add-dir` has no read-only form, and a read-only seat already
+    // has the file's contents in the appended block.
+    const addDirs = [...extraRoots];
+    if (memory?.writable && !addDirs.includes(memory.dir) && memory.dir !== session.projectPath)
+        addDirs.push(memory.dir);
     // `-p` is boolean (`--print`); the prompt is the positional `[prompt]`. It
     // goes LAST, behind the end-of-options marker, so a message that starts
     // with `-` (a bullet list, or a literal `--dangerously-skip-permissions`)
@@ -403,10 +649,17 @@ function buildClaudeLaunch(session, text, launch) {
         '--output-format', 'stream-json',
         '--verbose',
         '--include-partial-messages',
-        '--model', session.model,
+        // Always the CANONICAL id: `claude-opus-5.5` (an id Verse once shipped) is
+        // fuzzy-matched by the CLI to Opus 5, so a stored alias must never reach it.
+        '--model', canonicalModelId(session.model),
         '--permission-mode', 'acceptEdits',
         '--strict-mcp-config',
         '--mcp-config', '{"mcpServers":{}}',
+        ...autocompactArgs(session, launch),
+        // Local only: move the per-launch sections (cwd, env, git status) out of
+        // the system prompt so the local runner's prefix cache survives between
+        // turns. Claude seats keep the CLI default.
+        ...(isLocal ? ['--exclude-dynamic-system-prompt-sections'] : []),
         // VERIFIED against `claude --help` on 2.1.280:
         //   `--add-dir <directories...>  Additional directories to allow tool access to`
         // It is variadic, so it is spelled ONE DIRECTORY PER FLAG rather than
@@ -418,17 +671,25 @@ function buildClaudeLaunch(session, text, launch) {
         // option"), and `claude --add-dir /tmp --add-dir /private/var/tmp -p
         // --session-id NOTAUUID -- hi` got PAST option parsing to the downstream
         // "Invalid session ID" check, so both flags parsed.
-        ...extraRoots.flatMap((dir) => ['--add-dir', dir]),
+        ...addDirs.flatMap((dir) => ['--add-dir', dir]),
+        // The `=` spelling binds the block to the flag whatever its first
+        // character is — commander never re-reads it as an option.
+        ...(memory ? [`--append-system-prompt=${memory.block}`] : []),
         ...(session.turnCount > 0 ? ['--resume', session.nativeSessionId] : ['--session-id', session.nativeSessionId]),
         '--', text,
     ];
-    const env = session.engine === 'local'
+    const env = isLocal
         ? {
             // The launch record's dispatch address wins; `ollamaBaseUrl` is the
             // default lane and the fallback for records written before lanes existed.
             ANTHROPIC_BASE_URL: anthropicEnvBaseUrl(launch.anthropicBaseUrl ?? launch.ollamaBaseUrl),
             ANTHROPIC_AUTH_TOKEN: 'ollama',
             CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
+            // An Ollama tag is not a Claude id, so the CLI honours this as the
+            // model's window: auto-compaction and `result.modelUsage.contextWindow`
+            // then match what the runner actually serves. Not credential-shaped
+            // (`_TOKENS`), so the engine's env filter passes it through.
+            CLAUDE_CODE_MAX_CONTEXT_TOKENS: String(localContextWindow(session, launch)),
         }
         : {};
     return { argv, cwd: session.projectPath, env, stdin: null };