@ashlr/hub 3.7.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) --------------
@@ -3171,6 +3178,33 @@ function engineLocality(engine, cfg, env = process.env) {
 function providerLocality(providerId) {
   return LOCAL_PROVIDER_IDS.has(providerId.trim().toLowerCase()) ? "local" : "cloud";
 }
+function endpointMeteredness(baseUrl) {
+  if (typeof baseUrl !== "string" || baseUrl.trim().length === 0) return "unknown";
+  try {
+    new URL(baseUrl.trim());
+  } catch {
+    return "unknown";
+  }
+  return isLoopbackEndpoint(baseUrl) ? "free" : "metered";
+}
+function providerMeteredness(providerId) {
+  return LOCAL_PROVIDER_IDS.has(providerId.trim().toLowerCase()) ? "free" : "metered";
+}
+function engineMeteredness(engine, cfg, env = process.env) {
+  const id3 = engine.trim().toLowerCase();
+  if (id3 === ALWAYS_PERMITTED_ENGINE) return "free";
+  const spec = resolveEngineSpec(engine, cfg);
+  if (!spec) {
+    if (id3 === "llama-server") return endpointMeteredness(llamaServerBaseUrl(cfg, env));
+    return "unknown";
+  }
+  if (spec.kind === "builtin") return "free";
+  if (spec.kind === "cli-agent") return CLI_AGENT_METEREDNESS[id3] ?? "unknown";
+  const api = spec.api;
+  const fromEnv = api?.baseUrlEnv ? env[api.baseUrlEnv]?.trim() : void 0;
+  const baseUrl = (fromEnv && fromEnv.length > 0 ? fromEnv : void 0) ?? api?.defaultBaseUrl;
+  return endpointMeteredness(baseUrl);
+}
 function engineIdForBin(bin, cfg) {
   const raw = bin.trim();
   if (raw.length === 0) return void 0;
@@ -3186,25 +3220,37 @@ function engineIdForBin(bin, cfg) {
 }
 function decidePermission(subject, cfg, env = process.env) {
   const mode = resolveLocalOnlyMode(cfg, env);
-  if (!mode.enabled || subject.locality === "local") {
+  if (!mode.enabled || subject.meteredness === "free") {
     return { permitted: true, subject, mode, reason: null };
   }
   return { permitted: false, subject, mode, reason: refusalReason(subject, mode) };
 }
 function refusalReason(subject, mode) {
   const noun = SUBJECT_NOUN[subject.kind];
-  return `local-only: refusing to dispatch to cloud ${noun} '${subject.id}'. ${mode.detail} No cloud ${noun} is reachable while local-only is on \u2014 run this work on a local engine (builtin, local-coder, llama-server), or turn the mode off with cfg.foundry.localOnly=false (and unset ${LOCAL_ONLY_ENV_VAR}).`;
+  const head = subject.meteredness === "unknown" ? `local-only: refusing to dispatch to ${noun} '${subject.id}' \u2014 the hub cannot verify it is free. It may reach a paid backend after dispatch and nothing here would see it, so it is not provably free and is refused. ` : `local-only: refusing to dispatch to cloud ${noun} '${subject.id}'. `;
+  const tail = subject.meteredness === "unknown" ? "" : `No cloud ${noun} is reachable while local-only is on \u2014 `;
+  return `${head}${mode.detail} ${tail}run this work on a local engine (builtin, local-coder, llama-server), or turn the mode off with cfg.foundry.localOnly=false (and unset ${LOCAL_ONLY_ENV_VAR}).`;
 }
 function enginePermitted(engine, cfg, env = process.env) {
   return decidePermission(
-    { kind: "engine", id: engine, locality: engineLocality(engine, cfg, env) },
+    {
+      kind: "engine",
+      id: engine,
+      locality: engineLocality(engine, cfg, env),
+      meteredness: engineMeteredness(engine, cfg, env)
+    },
     cfg,
     env
   );
 }
 function providerPermitted(providerId, cfg, env = process.env) {
   return decidePermission(
-    { kind: "provider", id: providerId, locality: providerLocality(providerId) },
+    {
+      kind: "provider",
+      id: providerId,
+      locality: providerLocality(providerId),
+      meteredness: providerMeteredness(providerId)
+    },
     cfg,
     env
   );
@@ -3214,7 +3260,8 @@ function endpointPermitted(baseUrl, cfg, env = process.env) {
     {
       kind: "endpoint",
       id: baseUrl,
-      locality: isLoopbackEndpoint(baseUrl) ? "local" : "cloud"
+      locality: isLoopbackEndpoint(baseUrl) ? "local" : "cloud",
+      meteredness: endpointMeteredness(baseUrl)
     },
     cfg,
     env
@@ -3225,7 +3272,10 @@ function binPermitted(bin, cfg, env = process.env) {
   if (id3 === void 0) {
     return {
       permitted: true,
-      subject: { kind: "engine", id: bin, locality: "local" },
+      // Deliberate: an executable no engine claims is outside the roster this
+      // policy governs, so it is 'free' in the only sense that applies — the
+      // hub is not handing it a seat, or credentials, or work.
+      subject: { kind: "engine", id: bin, locality: "local", meteredness: "free" },
       mode: resolveLocalOnlyMode(cfg, env),
       reason: null
     };
@@ -3233,12 +3283,12 @@ function binPermitted(bin, cfg, env = process.env) {
   return enginePermitted(id3, cfg, env);
 }
 function cloudSubjectPermitted(kind, id3, cfg, env = process.env) {
-  return decidePermission({ kind, id: id3, locality: "cloud" }, cfg, env);
+  return decidePermission({ kind, id: id3, locality: "cloud", meteredness: "metered" }, cfg, env);
 }
 function assertPermitted(verdict) {
   if (!verdict.permitted) throw new LocalOnlyRefusal(verdict);
 }
-var LOCAL_ONLY_ENV_VAR, ENV_OFF_TOKENS, latchedConfigLocalOnly, LOCAL_CLI_AGENTS, LOCAL_PROVIDER_IDS, ALWAYS_PERMITTED_ENGINE, SUBJECT_NOUN, LocalOnlyRefusal;
+var LOCAL_ONLY_ENV_VAR, ENV_OFF_TOKENS, latchedConfigLocalOnly, LOCAL_CLI_AGENTS, LOCAL_PROVIDER_IDS, ALWAYS_PERMITTED_ENGINE, CLI_AGENT_METEREDNESS, SUBJECT_NOUN, LocalOnlyRefusal;
 var init_local_only = __esm({
   "src/core/policy/local-only.ts"() {
     "use strict";
@@ -3256,6 +3306,14 @@ var init_local_only = __esm({
       "builtin"
     ]);
     ALWAYS_PERMITTED_ENGINE = "builtin";
+    CLI_AGENT_METEREDNESS = Object.freeze({
+      claude: "metered",
+      codex: "metered",
+      hermes: "metered",
+      opencode: "metered",
+      ashlrcode: "metered",
+      aw: "unknown"
+    });
     SUBJECT_NOUN = {
       engine: "engine",
       provider: "provider",
@@ -29949,6 +30007,7 @@ var init_budget_alert = __esm({
 var init_budget = __esm({
   "src/core/run/budget.ts"() {
     "use strict";
+    init_local_only();
   }
 });
 

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