@giovannijecha/jecode 0.8.6 → 0.8.7

package/dist/controller-request.js

@@ -1,18 +1,22 @@
 // One streamed provider request with a single safe context-overflow recovery.
-import { budgetRequestFromInputTokens, estimateRequestInputTokensResponsive, } from "./context/budget.js";
+import { budgetRequestFromInputTokens, } from "./context/budget.js";
 import { isContextOverflow } from "./context/policy.js";
-import { projectToolResults, projectToolResultsNewest, toolResultProjectionBudget, } from "./context/request-projection.js";
-export async function requestAssistant(history, current, specs, options, events, signal) {
+import { fitRequestInput } from "./context/request.js";
+import { observePreparation, sendObserved } from "./context/request-observation.js";
+export async function requestAssistant(history, current, specs, options, events, meter, signal) {
+    let preparing = performance.now();
     let policy = await options.contextPolicy();
-    const prepared = await prepareContext(history, current, specs, options, events, policy, "budget", signal);
+    const prepared = await prepareContext(history, current, specs, options, events, meter, policy, "budget", signal);
     let context = prepared.context;
     let requestMessages = prepared.requestMessages;
     let inputTokens = prepared.inputTokens;
+    let measurement = prepared.measurement;
+    let clippedResults = prepared.clippedResults;
     let recovered = false;
     for (;;) {
         const budget = budgetRequestFromInputTokens(inputTokens, options.maxTokens, policy);
         try {
-            const message = await options.provider.send({
+            const message = await sendObserved(options.provider, {
                 model: options.model,
                 system: options.system,
                 messages: requestMessages,
@@ -25,59 +29,57 @@ export async function requestAssistant(history, current, specs, options, events,
                 signal,
                 onStream: (event) => events.onStream(event),
                 onStatus: (status) => events.onStatus?.(status),
-            });
-            return { message, context, inputTokens: budget.inputTokens };
+            }, measurement, policy, performance.now() - preparing, clippedResults);
+            return { message, context, inputTokens: budget.inputTokens, measurement };
         }
         catch (error) {
-            if (recovered)
+            if (recovered || !isContextOverflow(error))
                 throw error;
-            if (isContextOverflow(error))
-                policy = await options.contextPolicy();
-            const next = await prepareContext(history, context, specs, options, events, policy, "overflow", signal, error);
+            preparing = performance.now();
+            policy = await options.contextPolicy();
+            const next = await prepareContext(history, context, specs, options, events, meter, policy, "overflow", signal, error);
             if (sameContext(next.context, context))
                 throw error;
             context = next.context;
             requestMessages = next.requestMessages;
             inputTokens = next.inputTokens;
+            measurement = next.measurement;
+            clippedResults = next.clippedResults;
             recovered = true;
         }
     }
 }
-async function prepareContext(history, context, specs, options, events, policy, reason, signal, error) {
-    const projectionBudget = toolResultProjectionBudget(policy);
-    const initialProjection = projectToolResults(context, projectionBudget);
-    const initialRequest = initialProjection.messages;
-    const inputTokens = await estimateRequestInputTokensResponsive({
-        system: options.system,
-        messages: initialRequest,
-        tools: specs,
-    }, signal);
-    const projected = await events.onContext?.(history, context, {
-        reason,
-        policy,
-        inputTokens,
-        projectionSaturated: initialProjection.saturated,
-        ...(error === undefined ? {} : { error }),
+async function prepareContext(history, context, specs, options, events, meter, policy, reason, signal, error) {
+    return observePreparation(policy, reason, signal, async () => {
+        const input = {
+            model: options.model,
+            effort: options.effort,
+            system: options.system,
+            messages: [...context],
+            tools: specs,
+        };
+        const initial = await meter.measure(input, signal);
+        const projected = await events.onContext?.(history, context, {
+            reason,
+            policy,
+            inputTokens: initial.inputTokens,
+            ...(error === undefined ? {} : { error }),
+        });
+        const semantic = projected === undefined ? clone(context) : clone(projected);
+        if (projected !== undefined)
+            meter.reset();
+        const semanticInput = { ...input, messages: semantic };
+        const measurement = projected === undefined ? initial : await meter.measure(semanticInput, signal);
+        const fitted = await fitRequestInput(semanticInput, meter, policy, measurement, signal);
+        budgetRequestFromInputTokens(fitted.measurement.inputTokens, options.maxTokens, policy);
+        return {
+            context: semantic,
+            requestMessages: fitted.messages,
+            inputTokens: fitted.measurement.inputTokens,
+            measurement: fitted.measurement,
+            clippedResults: fitted.clippedResults,
+        };
     });
-    const semantic = projected === undefined ? clone(context) : clone(projected);
-    const stableProjection = projected === undefined
-        ? initialProjection
-        : projectToolResults(semantic, projectionBudget);
-    const requestMessages = stableProjection.saturated
-        ? projectToolResultsNewest(semantic, projectionBudget).messages
-        : stableProjection.messages;
-    const canReuseEstimate = projected === undefined && !stableProjection.saturated;
-    return {
-        context: semantic,
-        requestMessages,
-        inputTokens: canReuseEstimate
-            ? inputTokens
-            : await estimateRequestInputTokensResponsive({
-                system: options.system,
-                messages: requestMessages,
-                tools: specs,
-            }, signal),
-    };
 }
 function clone(messages) {
     return structuredClone([...messages]);

package/dist/controller.js

@@ -6,6 +6,7 @@
 import { isToolCall } from "./types.js";
 import { findTool, runTool, toolSpecs } from "./tools/index.js";
 import { requestAssistant } from "./controller-request.js";
+import { inputMeter } from "./context/measurement.js";
 export const MAX_TOOL_CALLS_PER_RESPONSE = 32;
 /** Independent read calls share one bounded execution wave. */
 export const MAX_CONCURRENT_TOOL_CALLS = 4;
@@ -16,6 +17,7 @@ export const MAX_CONCURRENT_TOOL_CALLS = 4;
  */
 export async function runTurn(history, options, events, signal, modelHistory = history) {
     const specs = toolSpecs(options.tools);
+    const meter = options.inputMeter ?? inputMeter(options.provider);
     let context = modelHistory;
     throwIfAborted(signal);
     const append = (message) => {
@@ -43,13 +45,13 @@ export async function runTurn(history, options, events, signal, modelHistory = h
         if (options.maxModelRequests !== undefined &&
             requests >= options.maxModelRequests) {
             const requestLabel = options.maxModelRequests === 1 ? "request" : "requests";
-            throw new Error(`stopped after ${options.maxModelRequests} model ${requestLabel} (--max-steps limit reached)`);
+            throw new Error(`stopped after ${options.maxModelRequests} model ${requestLabel} (request budget reached)`);
         }
         appendSteering(options.steering?.drain() ?? []);
         requests++;
         // The message is displayed as it streams; what comes back here is the
         // assembled version, which exists to be appended to the history.
-        const response = await requestAssistant(history, context, specs, options, events, signal);
+        const response = await requestAssistant(history, context, specs, options, events, meter, signal);
         const assistant = response.message;
         context = response.context;
         throwIfAborted(signal);
@@ -63,6 +65,7 @@ export async function runTurn(history, options, events, signal, modelHistory = h
         assertToolCallIds(calls);
         if (assistant.usage !== undefined)
             events.onUsage?.(assistant.usage);
+        meter.observe(response.measurement, assistant.usage?.inputTokens);
         events.onRequestInput?.(assistant.usage !== undefined && assistant.usage.inputTokens > 0
             ? assistant.usage.inputTokens
             : response.inputTokens);
@@ -193,11 +196,17 @@ async function settle(call, current, total, options, events, signal, preview) {
     if (tool === undefined) {
         return refuse(call, `no such tool: ${call.name}`, "unknown tool");
     }
+    if (options.toolAllowed?.(call) === false) {
+        return refuse(call, "this tool is denied by the current session permissions", "denied");
+    }
     const approved = !tool.dangerous || await events.approve(call);
     throwIfAborted(signal);
     if (!approved) {
         return refuse(call, "the user declined this call — ask them how to proceed", "declined");
     }
+    if (options.toolAllowed?.(call) === false) {
+        return refuse(call, "this tool is denied by the current session permissions", "denied");
+    }
     throwIfAborted(signal);
     events.onToolStart?.(call, current, total);
     return runTool(tool, call, {
@@ -223,6 +232,8 @@ function refuse(call, reason, summary) {
 async function look(call, options, signal) {
     if (call.inputError !== undefined)
         return undefined;
+    if (options.toolAllowed?.(call) === false)
+        return undefined;
     const tool = findTool(options.tools, call.name);
     if (tool?.preview === undefined)
         return undefined;

package/dist/input-boundary.js

@@ -1,6 +1,4 @@
 // One bounded ingress for text that can become a user prompt.
-import { Buffer } from "node:buffer";
-import { StringDecoder } from "node:string_decoder";
 import { MAX_TEXT_CODE_UNITS } from "./text-boundary.js";
 export const MAX_PROMPT_CODE_UNITS = MAX_TEXT_CODE_UNITS;
 export const PROMPT_LIMIT_MESSAGE = `Prompt cannot exceed ${MAX_PROMPT_CODE_UNITS.toLocaleString("en-US")} UTF-16 code units`;
@@ -18,63 +16,3 @@ export function assertPromptAppend(current, added) {
     if (added > MAX_PROMPT_CODE_UNITS - current)
         throw new PromptLimitError();
 }
-/**
- * Split raw UTF-8 input without letting one unterminated line grow past the
- * prompt boundary. Newline, CRLF, and a final line without a newline match the
- * line semantics used by batch mode.
- */
-export async function* boundedInputLines(source) {
-    const decoder = new StringDecoder("utf8");
-    let line = "";
-    let pendingCr = false;
-    const append = (text, from, to) => {
-        const length = to - from;
-        assertPromptAppend(line.length, length);
-        if (length > 0)
-            line += text.slice(from, to);
-    };
-    const consume = function* (text) {
-        if (text === "")
-            return;
-        let from = 0;
-        if (pendingCr) {
-            if (text.startsWith("\n"))
-                from = 1;
-            pendingCr = false;
-            yield line;
-            line = "";
-        }
-        while (from < text.length) {
-            const cr = text.indexOf("\r", from);
-            const lf = text.indexOf("\n", from);
-            const newline = cr === -1 ? lf : lf === -1 ? cr : Math.min(cr, lf);
-            if (newline === -1) {
-                append(text, from, text.length);
-                return;
-            }
-            append(text, from, newline);
-            if (text[newline] === "\r" && newline + 1 === text.length) {
-                pendingCr = true;
-                return;
-            }
-            yield line;
-            line = "";
-            from = text[newline] === "\r" && text[newline + 1] === "\n"
-                ? newline + 2
-                : newline + 1;
-        }
-    };
-    for await (const chunk of source) {
-        const text = typeof chunk === "string" ? chunk : decoder.write(Buffer.from(chunk));
-        yield* consume(text);
-    }
-    const tail = decoder.end();
-    if (tail !== "")
-        yield* consume(tail);
-    if (pendingCr) {
-        yield line;
-        line = "";
-    }
-    if (line !== "")
-        yield line;
-}

package/dist/launch.js

@@ -1,19 +1,23 @@
 export function parseLaunch(argv) {
+    if (argv.includes("--latest")) {
+        throw new Error("--latest has been renamed to --last; use `jecode -c` or `jecode resume --last`");
+    }
     const first = argv[0];
-    if (first !== undefined && !first.startsWith("--") && first !== "-h" && first !== "-v") {
-        if (first !== "resume")
-            throw new Error(`unknown command ${first}`);
-        const rest = argv.slice(1);
-        const latest = rest.filter((value) => value === "--latest").length;
+    if (first === "resume" || first === "-c") {
+        const rest = first === "-c" ? ["--last", ...argv.slice(1)] : argv.slice(1);
+        const latest = rest.filter((value) => value === "--last").length;
         if (latest > 1)
-            throw new Error("--latest may be passed only once");
+            throw new Error("--last may be passed only once; -c already selects the last session");
         return {
             kind: "resume",
             latest: latest === 1,
-            configArgs: rest.filter((value) => value !== "--latest"),
+            configArgs: rest.filter((value) => value !== "--last"),
         };
     }
-    if (argv.includes("--latest"))
-        throw new Error("--latest requires `jecode resume`");
+    if (first !== undefined && !first.startsWith("--") && first !== "-h" && first !== "-v") {
+        throw new Error(`unknown command ${first}`);
+    }
+    if (argv.includes("--last"))
+        throw new Error("--last requires `jecode resume`; use `jecode -c` to continue directly");
     return { kind: "new", latest: false, configArgs: [...argv] };
 }

package/dist/model-command.js

@@ -17,9 +17,6 @@ export async function modelsCommand(session, host, behavior = {}, providers = PR
     const connected = availability
         .filter((entry) => entry.blocked === undefined)
         .map((entry) => entry.provider);
-    const disconnected = availability
-        .filter((entry) => entry.blocked !== undefined)
-        .map((entry) => entry.provider);
     if (connected.length === 0) {
         host.emit({
             kind: "notice",
@@ -68,10 +65,15 @@ export async function modelsCommand(session, host, behavior = {}, providers = PR
         });
         return false;
     }
-    const description = catalogDescription(disconnected, failed);
+    if (failed.length > 0) {
+        host.emit({
+            kind: "notice",
+            text: `model catalogs unavailable: ${failed.map((entry) => providerLabel(entry.provider.id)).join(", ")}`,
+            tone: "warn",
+        });
+    }
     const index = await choose({
         title: [],
-        ...(description === undefined ? {} : { description }),
         options: choices.map((choice) => ({
             label: choice.model,
             // Provider identity is part of the choice, not optional help: keep it
@@ -136,18 +138,6 @@ async function alignEffort(provider, model, effort, host) {
         return { ok: false };
     }
 }
-function catalogDescription(disconnected, failed) {
-    const parts = [
-        "The connection on the right will run this model; API and account usage stay separate",
-        disconnected.length === 0
-            ? undefined
-            : `Not connected: ${disconnected.map((provider) => providerLabel(provider.id)).join(", ")}`,
-        failed.length === 0
-            ? undefined
-            : `Unavailable: ${failed.map((entry) => providerLabel(entry.provider.id)).join(", ")}`,
-    ].filter((part) => part !== undefined);
-    return `${parts.join(" · ")} · manage access in /providers`;
-}
 function emptyCatalogMessage(connected, failed) {
     if (failed.length === 1 && connected.length === 1) {
         const one = failed[0];

package/dist/oauth-result-page.js

@@ -0,0 +1,68 @@
+// The browser handoff back to the terminal after account sign-in.
+import { readFileSync } from "node:fs";
+export function oauthResultPage(success) {
+    const title = success ? "You're signed in" : "Sign-in failed";
+    const detail = success
+        ? "Return to your terminal. You can close this tab."
+        : "Return to your terminal to try again.";
+    return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <meta name="color-scheme" content="dark">
+  <title>${title} · Jecode</title>
+  <style>
+    :root {
+      color-scheme: dark;
+      --background: #1c2026;
+      --text: #ebeff4;
+      --muted: #9ca9b7;
+      --accent: #669bd2;
+      --error: #e87070;
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      min-height: 100vh;
+      min-height: 100svh;
+      display: grid;
+      place-items: center;
+      background: var(--background);
+      color: var(--text);
+      font-family: "Segoe UI", system-ui, sans-serif;
+    }
+    main { width: min(28rem, 100%); padding: 2rem; }
+    .identity { display: flex; align-items: center; gap: .75rem; margin-bottom: 2rem; }
+    .identity img { display: block; width: 3rem; height: 3rem; }
+    .identity span {
+      color: var(--accent);
+      font: 600 1.25rem/1 ui-monospace, "Cascadia Mono", Consolas, monospace;
+      letter-spacing: -.04em;
+    }
+    h1 { margin: 0; font-size: 1.75rem; font-weight: 600; line-height: 1.25; letter-spacing: -.025em; }
+    p { margin: .75rem 0 0; color: var(--muted); font-size: 1rem; line-height: 1.6; }
+    .failure h1 { color: var(--error); }
+  </style>
+</head>
+<body>
+  <main${success ? "" : ' class="failure"'}>
+    <div class="identity">
+      <img src="${mascotDataUri()}" width="48" height="48" alt="">
+      <span>jecode</span>
+    </div>
+    <h1>${title}</h1>
+    <p>${detail}</p>
+  </main>
+  <script>history.replaceState(null,"","/auth/complete")</script>
+</body>
+</html>`;
+}
+let mascot;
+function mascotDataUri() {
+    if (mascot === undefined) {
+        const file = new URL("../assets/jeco-256.png", import.meta.url);
+        mascot = `data:image/png;base64,${readFileSync(file).toString("base64")}`;
+    }
+    return mascot;
+}

package/dist/openai-oauth-callback.js

@@ -1,9 +1,9 @@
 // Loopback callback used by the browser OAuth flow.
 import { timingSafeEqual } from "node:crypto";
-import { readFileSync } from "node:fs";
 import { createServer } from "node:http";
 import { leadingText } from "./text-boundary.js";
 import { providerLabel } from "./provider-label.js";
+import { oauthResultPage } from "./oauth-result-page.js";
 const ACCOUNT_LABEL = providerLabel("openai-codex");
 const CALLBACK_PORTS = [1455, 1457];
 export const OPENAI_CALLBACK_PATH = "/auth/callback";
@@ -80,7 +80,7 @@ export async function openAICallback(state) {
                 "referrer-policy": "no-referrer",
                 "x-content-type-options": "nosniff",
             });
-            response.end(resultPage(success));
+            response.end(oauthResultPage(success));
             await flushed;
         },
         close: () => closeServer(listening.server),
@@ -139,54 +139,6 @@ function closeServer(server) {
         server.closeIdleConnections();
     });
 }
-function resultPage(success) {
-    const title = success ? "Signed in to Jecode" : "Jecode sign-in failed";
-    const status = success ? "Authentication complete" : "Authentication stopped";
-    const detail = success
-        ? "Return to your terminal. Jecode will continue automatically."
-        : "Return to your terminal to see what stopped the connection.";
-    const state = success ? "success" : "failure";
-    return `<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <meta name="color-scheme" content="dark">
-  <title>${title}</title>
-  <style>
-    :root{--night:#000;--steel:#669bd2;--steel-soft:#8db4dd;--bright:#ebeff4;--danger:#e87070}
-    *{box-sizing:border-box}
-    body{margin:0;min-height:100vh;display:grid;place-items:center;background:var(--night);color:var(--steel-soft);font-family:"Segoe UI",system-ui,sans-serif}
-    main{width:min(34rem,calc(100vw - 3rem));padding:3rem 1.5rem;text-align:center}
-    img{display:block;width:clamp(7.5rem,20vw,10rem);height:auto;margin:0 auto 1.75rem;filter:drop-shadow(0 1.25rem 2rem rgba(102,155,210,.16))}
-    .rail{width:min(18rem,70vw);height:1px;margin:0 auto 1.5rem;background:linear-gradient(90deg,transparent,var(--steel),transparent)}
-    .status{margin:0 0 .75rem;color:var(--steel);font:600 .72rem/1.2 ui-monospace,"Cascadia Mono",monospace;letter-spacing:.14em;text-transform:uppercase}
-    h1{margin:0;color:var(--steel);font-size:clamp(2rem,6vw,3.25rem);font-weight:720;letter-spacing:-.04em;line-height:1.05}
-    p:last-of-type{max-width:30rem;margin:1.25rem auto 0;color:var(--steel-soft);font-size:1.05rem;line-height:1.6}
-    .failure h1,.failure .status{color:var(--danger)}
-    @media (prefers-reduced-motion:no-preference){main{animation:arrive .45s ease-out both}@keyframes arrive{from{opacity:0;transform:translateY(.6rem)}to{opacity:1;transform:none}}}
-  </style>
-</head>
-<body>
-  <main class="${state}">
-    <img src="${mascotDataUri()}" alt="Jeco, the Jecode gecko">
-    <div class="rail" aria-hidden="true"></div>
-    <p class="status">${status}</p>
-    <h1>${title}</h1>
-    <p>${detail}</p>
-  </main>
-  <script>history.replaceState(null,"","/auth/complete")</script>
-</body>
-</html>`;
-}
-let mascot;
-function mascotDataUri() {
-    if (mascot === undefined) {
-        const file = new URL("../assets/jeco-256.png", import.meta.url);
-        mascot = `data:image/png;base64,${readFileSync(file).toString("base64")}`;
-    }
-    return mascot;
-}
 function sameState(expected, received) {
     if (received === null)
         return false;

package/dist/permission-command.js

@@ -9,17 +9,13 @@ export async function permissionsCommand(session, host) {
     }
     let selected = 0;
     while (true) {
-        const index = await choose(permissionControlPicker(control, host, selected));
+        const index = await choose(permissionControlPicker(control, selected));
         if (index === undefined)
             return;
         const tool = control.listTools()[index];
         if (tool === undefined)
             return;
         selected = index;
-        if (tool.locked) {
-            lockedNotice(tool.name, host);
-            continue;
-        }
         if (tool.remembered > 0) {
             await reviewGrants(tool.name, control, choose, session.palette);
         }
@@ -29,12 +25,12 @@ export function permissionsPicker(tools, index = 0, adjust) {
     return {
         title: [],
         options: tools.map((tool) => {
-            const description = toolDescription(tool);
+            const hint = toolHint(tool);
             return {
                 label: tool.name,
-                ...(description === undefined ? {} : { description }),
-                value: tool.locked ? `${tool.mode} · locked` : tool.mode,
-                adjustable: !tool.locked,
+                ...(hint === undefined ? {} : { hint }),
+                value: tool.mode,
+                adjustable: true,
             };
         }),
         visible: tools.length,
@@ -42,21 +38,17 @@ export function permissionsPicker(tools, index = 0, adjust) {
         index: Math.min(Math.max(0, index), Math.max(0, tools.length - 1)),
     };
 }
-export function permissionControlPicker(control, host, selected) {
+export function permissionControlPicker(control, selected) {
     return permissionsPicker(control.listTools(), selected, (index, step) => {
         const tool = control.listTools()[index];
         if (tool === undefined)
-            return permissionControlPicker(control, host, selected);
-        if (tool.locked) {
-            lockedNotice(tool.name, host);
-            return permissionControlPicker(control, host, index);
-        }
+            return permissionControlPicker(control, selected);
         const modes = modesFor(tool);
         const at = Math.max(0, modes.indexOf(tool.mode));
         const next = modes[(at + step + modes.length) % modes.length];
         if (next !== undefined)
             control.set(tool.name, next);
-        return permissionControlPicker(control, host, index);
+        return permissionControlPicker(control, index);
     });
 }
 async function reviewGrants(tool, control, choose, pal) {
@@ -90,17 +82,10 @@ async function reviewGrants(tool, control, choose, pal) {
 function modesFor(tool) {
     return tool.dangerous ? ["ask", "allow", "deny"] : ["allow", "deny"];
 }
-function toolDescription(tool) {
+function toolHint(tool) {
     const parts = [
         tool.dangerous ? undefined : "read only",
         tool.remembered === 0 ? undefined : `${tool.remembered} remembered`,
     ].filter((part) => part !== undefined);
     return parts.length === 0 ? undefined : parts.join(" · ");
 }
-function lockedNotice(tool, host) {
-    host.emit({
-        kind: "notice",
-        text: `restart without --auto-approve to change ${tool}`,
-        tone: "warn",
-    });
-}

package/dist/permissions.js

@@ -1,12 +1,11 @@
 // Session-local tool policies and remembered approval scopes.
 /** One permission control plane for one interactive process. */
-export function sessionPermissions(tools, autoApprove) {
+export function sessionPermissions(tools) {
     const catalogue = [...tools];
     const byName = new Map(catalogue.map((tool) => [tool.name, tool]));
     const modes = new Map();
     const grants = new Map();
     const configured = (tool) => modes.get(tool.name) ?? defaultMode(tool);
-    const effective = (tool) => autoApprove && tool.dangerous ? "allow" : configured(tool);
     const revokeTool = (name) => {
         for (const [key, grant] of grants) {
             if (grant.tools.includes(name))
@@ -18,14 +17,13 @@ export function sessionPermissions(tools, autoApprove) {
             return catalogue.map((tool) => ({
                 name: tool.name,
                 dangerous: tool.dangerous,
-                mode: effective(tool),
+                mode: configured(tool),
                 remembered: [...grants.values()].filter((grant) => grant.tools.includes(tool.name)).length,
-                locked: autoApprove && tool.dangerous,
             }));
         },
         set(name, mode) {
             const tool = byName.get(name);
-            if (tool === undefined || (autoApprove && tool.dangerous))
+            if (tool === undefined)
                 return false;
             if (!tool.dangerous && mode === "ask")
                 return false;
@@ -50,13 +48,17 @@ export function sessionPermissions(tools, autoApprove) {
             grants.clear();
         },
         availableTools() {
-            return catalogue.filter((tool) => effective(tool) !== "deny");
+            return catalogue.filter((tool) => configured(tool) !== "deny");
+        },
+        allowed(call) {
+            const tool = byName.get(call.name);
+            return tool !== undefined && configured(tool) !== "deny";
         },
         approved(call) {
             const tool = byName.get(call.name);
             if (tool === undefined)
                 return false;
-            const mode = effective(tool);
+            const mode = configured(tool);
             if (mode === "allow")
                 return true;
             if (mode === "deny")
@@ -65,7 +67,7 @@ export function sessionPermissions(tools, autoApprove) {
         },
         remember(call) {
             const tool = byName.get(call.name);
-            if (tool === undefined || effective(tool) !== "ask")
+            if (tool === undefined || configured(tool) !== "ask")
                 return;
             const scope = scopeFor(call);
             grants.set(scope.key, { key: scope.key, tools: grantTools(call), label: scope.summary });

package/dist/providers/anthropic-wire.js

@@ -38,7 +38,7 @@ export function stopNotice(data) {
         return `[refused: ${category}] ${why}`;
     }
     if (data.stop_reason === "max_tokens") {
-        return "[truncated: hit max_tokens — raise --max-tokens]";
+        return "[truncated: hit max_tokens — raise max output tokens in /settings]";
     }
     return undefined;
 }

package/dist/providers/anthropic.js

@@ -13,6 +13,7 @@ import { EFFORTS, requireSupportedEffort } from "../effort.js";
 import { assembleAnthropic } from "./anthropic-stream.js";
 import { isRetryableGenerationFailure, isRetryableReadFailure, throwProviderError, } from "./failure.js";
 import { fromWireResponse, stopNotice, toWireMessage, toWireTool } from "./anthropic-wire.js";
+import { measureAnthropicInput } from "./input-measurement.js";
 const ENDPOINT = "https://api.anthropic.com/v1/messages";
 const MODELS = "https://api.anthropic.com/v1/models?limit=100";
 const API_VERSION = "2023-06-01";
@@ -36,7 +37,7 @@ export function anthropicEfforts(model) {
 export const anthropic = {
     id: ID,
     // Sonnet is the default because it is the one that can be left running.
-    // Opus via `--model claude-opus-5`, Haiku via `--model claude-haiku-4-5`.
+    // Other models are selected through the shared model catalogue.
     defaultModel: "claude-sonnet-5",
     auth: { kind: "api-key", keyVar: KEY },
     blocked() {
@@ -72,6 +73,7 @@ export const anthropic = {
             throwProviderError(ID, signal, error);
         }
     },
+    measureInput: measureAnthropicInput,
     async send(req) {
         const key = requireKey();
         const body = {