neoctl 0.2.0 → 0.2.1

package/dist/web/html.js

@@ -686,8 +686,7 @@ async function submit() {
   input.value = '';
   state.attachments = [];
   if (state.busy) {
-    state.busy = false;
-    state.queuedInput = undefined;
+    state.queuedInput = text;
   }
   autosize();
   renderCompletions();
@@ -752,8 +751,8 @@ input.addEventListener('keydown', (e) => {
   if (e.key === 'ArrowUp' && !input.value) { e.preventDefault(); advanceTip(-1); return; }
   if (e.key === 'ArrowDown' && state.historyIndex !== undefined) { e.preventDefault(); state.historyIndex -= 1; if (state.historyIndex < 0) { state.historyIndex = undefined; input.value = ''; } else input.value = state.history[state.historyIndex] || ''; autosize(); return; }
   if (e.key === 'ArrowDown' && !input.value) { e.preventDefault(); advanceTip(); return; }
-  if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === 'c') { if (input.value) { input.value = ''; autosize(); renderCompletions(); } else fetch('/api/interrupt', { method: 'POST' }); }
-  if (e.key === 'Escape') { state.completionIndex = 0; if (state.queuedInput) fetch('/api/interrupt', { method: 'POST' }); else renderCompletions(); }
+  if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === 'c') { if (input.value) { input.value = ''; autosize(); renderCompletions(); } else if (state.queuedInput) { state.queuedInput = undefined; scheduleRender(); fetch('/api/queue/cancel', { method: 'POST' }); } else fetch('/api/interrupt', { method: 'POST' }); }
+  if (e.key === 'Escape') { state.completionIndex = 0; if (state.queuedInput) { state.queuedInput = undefined; scheduleRender(); fetch('/api/queue/cancel', { method: 'POST' }); } else renderCompletions(); }
 });
 document.addEventListener('keydown', (e) => {
   if (e.target === input || e.target.closest('input, textarea, select')) return;

package/dist/web/html.js.map

@@ -1 +1 @@
-{"version":3,"file":"html.js","sourceRoot":"","sources":["../../src/web/html.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA41B1B,CAAC"}
+{"version":3,"file":"html.js","sourceRoot":"","sources":["../../src/web/html.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA21B1B,CAAC"}

package/dist/web/index.d.ts

@@ -13,7 +13,7 @@ export interface WebRuntime {
     communicationLogger: CommunicationLogger;
     modelGateway: LoggingModelGateway;
     agentRuntime: AgentToolRuntime;
-    usage: SessionUsageTracker;
+    usage: WebSessionUsageTracker;
     taskStore: TaskStore;
     tools: ToolRegistry;
     initialMetrics: ContextMetrics;
@@ -21,7 +21,7 @@ export interface WebRuntime {
     envPath: string;
     envNotice?: string;
 }
-export interface UsageTotals {
+interface WebUsageTotals {
     inputTokens: number;
     outputTokens: number;
     totalTokens: number;
@@ -30,12 +30,12 @@ export interface UsageTotals {
     requests: number;
     computedTotalTokens: boolean;
 }
-export declare class SessionUsageTracker {
+declare class WebSessionUsageTracker {
     private totals;
     private lastUsage?;
     add(usage: ModelUsage): void;
     reset(): void;
-    snapshot(): UsageTotals;
+    snapshot(): WebUsageTotals;
 }
 interface UiLineImage {
     src: string;
@@ -140,6 +140,7 @@ export declare class WebRepl {
     private status;
     private busy;
     private queuedInput;
+    private queuedAttachments;
     private foregroundRun;
     private foregroundRunToken;
     private readonly backgroundSessionRuns;
@@ -165,7 +166,7 @@ export declare class WebRepl {
         runningSessionIds: string[];
         session: import("../index.js").SessionStoreSnapshot | undefined;
         catalog: {
-            commands: import("../repl/commands.js").ReplCommandDefinition[];
+            commands: import("../core/commands.js").RuntimeCommandDefinition[];
             modelIds: string[];
             reasoning: string[];
             envPath: string;
@@ -183,6 +184,7 @@ export declare class WebRepl {
         ok: false;
         error: string;
     }>;
+    private startRun;
     listSessions(): Promise<{
         sessions: import("../index.js").SessionSummary[];
         runningSessionIds: string[];
@@ -217,6 +219,10 @@ export declare class WebRepl {
         ok: true;
         interrupted: boolean;
     };
+    cancelQueue(): {
+        ok: true;
+        cancelled: boolean;
+    };
     private append;
     private updateLine;
     private replaceLineText;

package/dist/web/index.js

@@ -20,11 +20,11 @@ import { grepTool } from "../tools/builtins/grep-tool.js";
 import { searchTool } from "../tools/builtins/search-tool.js";
 import { planTool } from "../tools/builtins/plan-tool.js";
 import { createOpenAIImageGenerationTool } from "../tools/builtins/image-generation-tool.js";
-import { createVisionTool } from "../tools/builtins/vision-tool.js";
+import { createLoadImageTool } from "../tools/builtins/image-loader-tool.js";
 import { createAgentTool, resumeAgentTask } from "../agents/agent-tool.js";
 import { createTaskTools } from "../tasks/task-tools.js";
 import { TaskStore } from "../tasks/task-store.js";
-import { parseReplCommand, helpText, replCommandDefinitions } from "../repl/commands.js";
+import { parseReplCommand, helpText, replCommandDefinitions } from "../core/commands.js";
 import { writeSessionMarkdownExport } from "../session/session-export.js";
 import { WEB_HTML } from "./html.js";
 import { appTips, formatTipLine, initialTipIndex, tipAt } from "../tips.js";
@@ -35,8 +35,8 @@ const highlightPackageDir = path.dirname(require.resolve("@highlightjs/cdn-asset
 const markedAssetPath = path.join(markedPackageDir, "lib", "marked.esm.js");
 const highlightAssetPath = path.join(highlightPackageDir, "highlight.min.js");
 const highlightThemeAssetPath = path.join(highlightPackageDir, "styles", "atom-one-dark.min.css");
-export class SessionUsageTracker {
-    totals = emptyUsageTotals();
+class WebSessionUsageTracker {
+    totals = emptyWebUsageTotals();
     lastUsage;
     add(usage) {
         if (usage === this.lastUsage)
@@ -61,14 +61,14 @@ export class SessionUsageTracker {
         };
     }
     reset() {
-        this.totals = emptyUsageTotals();
+        this.totals = emptyWebUsageTotals();
         this.lastUsage = undefined;
     }
     snapshot() {
         return { ...this.totals };
     }
 }
-function emptyUsageTotals() {
+function emptyWebUsageTotals() {
     return { inputTokens: 0, outputTokens: 0, totalTokens: 0, reasoningTokens: 0, cachedTokens: 0, requests: 0, computedTotalTokens: false };
 }
 function usageTokenValue(value) {
@@ -121,7 +121,7 @@ export async function createWebRuntime(options = {}) {
     tools.register(readFileTool);
     tools.register(grepTool);
     tools.register(searchTool);
-    tools.register(createVisionTool({ modelGateway, model: modelConfig?.model }));
+    tools.register(createLoadImageTool());
     if (modelConfig?.provider === "openai")
         tools.register(createOpenAIImageGenerationTool());
     tools.register(planTool);
@@ -163,7 +163,7 @@ export async function createWebRuntime(options = {}) {
         communicationLogger,
         modelGateway,
         agentRuntime,
-        usage: new SessionUsageTracker(),
+        usage: new WebSessionUsageTracker(),
         taskStore,
         tools,
         initialMetrics,
@@ -193,12 +193,8 @@ function syncImageGenerationTool(runtime, provider) {
     if (provider === "openai")
         runtime.tools.register(createOpenAIImageGenerationTool());
 }
-function syncVisionTool(runtime, model) {
-    runtime.tools.unregister("vision");
-    runtime.tools.register(createVisionTool({ modelGateway: runtime.modelGateway, model }));
-}
 function formatCreatedEnvNotice(dotEnvPath) {
-    return `Created default config file: ${dotEnvPath}\nSet MODEL_PROVIDER and the matching provider section (for example OPENAI_API_KEY or KIMI_API_KEY), then restart neo.`;
+    return `Created default config file: ${dotEnvPath}\nSet MODEL_PROVIDER and the matching provider section (for example OPENAI_API_KEY, ANTHROPIC_API_KEY, or KIMI_API_KEY), then restart neo.`;
 }
 function parseResumeFlag(value) {
     if (!value)
@@ -258,6 +254,7 @@ export class WebRepl {
     status;
     busy = false;
     queuedInput;
+    queuedAttachments;
     foregroundRun;
     foregroundRunToken = 0;
     backgroundSessionRuns = new Map();
@@ -315,8 +312,15 @@ export class WebRepl {
             await this.detachRunningForeground("session browser");
         }
         else if (this.busy) {
-            this.stopForegroundRun("Interrupted by new prompt");
+            this.queuedInput = text;
+            this.queuedAttachments = attachments;
+            this.broadcastSync();
+            return { ok: true };
         }
+        this.startRun(text, attachments);
+        return { ok: true };
+    }
+    startRun(text, attachments = []) {
         const run = this.handleCommandOrPrompt(text, attachments).catch((error) => {
             this.append({ kind: "error", text: error instanceof Error ? error.message : String(error) });
             this.setBusy(false);
@@ -327,7 +331,6 @@ export class WebRepl {
             if (this.foregroundRun === run)
                 this.foregroundRun = undefined;
         }).catch(() => undefined);
-        return { ok: true };
     }
     async listSessions() {
         const sessions = await this.runtime.engine.listSessions(Number.POSITIVE_INFINITY);
@@ -413,7 +416,7 @@ export class WebRepl {
     async saveLogin(providerValue, values) {
         const provider = parseLoginProvider(providerValue);
         if (!provider)
-            return { ok: false, error: "provider must be openai, deepseek, or kimi" };
+            return { ok: false, error: "provider must be openai, anthropic, deepseek, or kimi" };
         const payload = { ...createLoginFormPayload(this.runtime.envPath, provider), provider, values };
         const validationError = validateLoginFormPayload(payload);
         if (validationError)
@@ -429,7 +432,6 @@ export class WebRepl {
             this.runtime.agentRuntime.modelGateway = this.runtime.modelGateway;
             this.runtime.engine.setModelProvider({ modelGateway: this.runtime.modelGateway, model: config.model, fallbackModel: config.fallbackModel, reasoning: config.defaultReasoning });
             syncImageGenerationTool(this.runtime, config.provider);
-            syncVisionTool(this.runtime, config.model);
             this.runtime.defaultReasoning = config.defaultReasoning;
             const metrics = await this.runtime.engine.contextMetrics();
             this.setStatus({ ...this.status, metrics, activityTick: this.status.activityTick + 1 });
@@ -446,6 +448,14 @@ export class WebRepl {
         const interrupted = this.stopForegroundRun("Interrupted from neo web");
         return { ok: true, interrupted };
     }
+    cancelQueue() {
+        const had = this.queuedInput !== undefined;
+        this.queuedInput = undefined;
+        this.queuedAttachments = undefined;
+        if (had)
+            this.broadcastSync();
+        return { ok: true, cancelled: had };
+    }
     append(line) {
         const id = ++this.lineId;
         this.lines.push({ id, ...line });
@@ -490,6 +500,7 @@ export class WebRepl {
         this.activeAbortController = undefined;
         this.interruptArmed = false;
         this.queuedInput = undefined;
+        this.queuedAttachments = undefined;
         this.finalizeForegroundView();
         this.busy = false;
         this.status = { ...this.status, phase: "ready", detail: undefined, inputTokenUpdatedAt: undefined, outputTokenUpdatedAt: undefined, retryCooldownUntil: undefined };
@@ -534,6 +545,7 @@ export class WebRepl {
         this.activeAbortController = undefined;
         this.interruptArmed = false;
         this.queuedInput = undefined;
+        this.queuedAttachments = undefined;
         this.busy = false;
         this.status = { ...this.status, phase: "ready", detail: undefined };
         this.append(systemLine(`Detached running ${sessionId} to background for ${reason}.`));
@@ -675,7 +687,7 @@ export class WebRepl {
         if (command.type === "help")
             return void this.append(systemLine(helpText, EXPANDED_SUMMARY_MAX_LINES));
         if (command.type === "cost")
-            return void this.append({ kind: "system", text: formatUsageTotals(this.runtime.usage.snapshot()), previewStyle: "summary" });
+            return void this.append({ kind: "system", text: formatWebUsageTotals(this.runtime.usage.snapshot()), previewStyle: "summary" });
         if (command.type === "reset") {
             this.runtime.engine.reset();
             this.runtime.usage.reset();
@@ -794,9 +806,19 @@ export class WebRepl {
                 this.activeAbortController = undefined;
             this.interruptArmed = false;
             this.finalizeForegroundView();
-            this.setBusy(false);
-            this.setStatus({ ...this.status, phase: "ready", detail: undefined, inputTokenUpdatedAt: undefined, outputTokenUpdatedAt: undefined, retryCooldownUntil: undefined });
-            this.broadcastSync();
+            const queuedText = this.queuedInput;
+            const queuedAttach = this.queuedAttachments;
+            this.queuedInput = undefined;
+            this.queuedAttachments = undefined;
+            if (queuedText !== undefined) {
+                this.startRun(queuedText, queuedAttach ?? []);
+                this.broadcastSync();
+            }
+            else {
+                this.setBusy(false);
+                this.setStatus({ ...this.status, phase: "ready", detail: undefined, inputTokenUpdatedAt: undefined, outputTokenUpdatedAt: undefined, retryCooldownUntil: undefined });
+                this.broadcastSync();
+            }
         }
     }
     async runCompaction(type) {
@@ -870,6 +892,8 @@ async function route(req, res, router) {
         }
         if (req.method === "POST" && url.pathname === "/api/interrupt")
             return sendJson(res, repl.interrupt());
+        if (req.method === "POST" && url.pathname === "/api/queue/cancel")
+            return sendJson(res, repl.cancelQueue());
         if (req.method === "GET" && url.pathname === "/api/sessions")
             return sendJson(res, await repl.listSessions());
         if (req.method === "POST" && url.pathname === "/api/sessions/resume") {
@@ -1086,7 +1110,6 @@ async function handleModelCommand(command, runtime) {
                     runtime.agentRuntime.modelGateway = runtime.modelGateway;
                     runtime.engine.setModelProvider({ modelGateway: runtime.modelGateway, model: config.model, fallbackModel: config.fallbackModel, reasoning: config.defaultReasoning });
                     syncImageGenerationTool(runtime, config.provider);
-                    syncVisionTool(runtime, config.model);
                     runtime.defaultReasoning = config.defaultReasoning;
                 }
             }
@@ -1137,14 +1160,14 @@ async function persistModelCommandSettings(runtime, command, reasoningUpdate) {
     return { providerChanged: targetProvider !== currentProvider };
 }
 function currentModelProvider() {
-    return parseLoginProvider(process.env.MODEL_PROVIDER) ?? "openai";
+    return parseLoginProvider(process.env.MODEL_PROVIDER) ?? (process.env.ANTHROPIC_API_KEY ? "anthropic" : "openai");
 }
 function parseLoginProvider(value) {
-    if (value === "openai" || value === "deepseek" || value === "kimi")
+    if (value === "openai" || value === "anthropic" || value === "deepseek" || value === "kimi")
         return value;
     return undefined;
 }
-const LOGIN_PROVIDERS = ["openai", "deepseek", "kimi"];
+const LOGIN_PROVIDERS = ["openai", "anthropic", "deepseek", "kimi"];
 const SHARED_LOGIN_FIELDS = [
     { key: "reasoningEffort", label: "Reasoning effort", envKey: "MODEL_REASONING_EFFORT", scope: "shared", options: ["", "off", "none", "minimal", "low", "medium", "high", "xhigh", "max"] },
     { key: "reasoningSummary", label: "Reasoning summary", envKey: "MODEL_REASONING_SUMMARY", scope: "shared", options: ["", "auto", "concise", "detailed"] },
@@ -1162,6 +1185,14 @@ const LOGIN_FIELD_DEFINITIONS = {
         { key: "endpoint", label: "Endpoint", envKey: "OPENAI_ENDPOINT", scope: "provider", placeholder: "auto", options: ["auto", "responses", "chat"] },
         ...SHARED_LOGIN_FIELDS,
     ],
+    anthropic: [
+        { key: "apiKey", label: "API key", envKey: "ANTHROPIC_API_KEY", scope: "provider", required: true, secret: true, placeholder: "sk-ant-..." },
+        { key: "baseUrl", label: "Base URL", envKey: "ANTHROPIC_BASE_URL", scope: "provider", placeholder: "https://api.anthropic.com" },
+        { key: "model", label: "Model", envKey: "ANTHROPIC_MODEL", scope: "provider", required: true, placeholder: "claude-sonnet-4-6" },
+        { key: "fallbackModel", label: "Fallback model", envKey: "ANTHROPIC_FALLBACK_MODEL", scope: "provider" },
+        { key: "version", label: "Anthropic version", envKey: "ANTHROPIC_VERSION", scope: "provider", placeholder: "2023-06-01" },
+        ...SHARED_LOGIN_FIELDS,
+    ],
     deepseek: [
         { key: "apiKey", label: "API key", envKey: "DEEPSEEK_API_KEY", scope: "provider", required: true, secret: true, placeholder: "sk-..." },
         { key: "baseUrl", label: "Base URL", envKey: "DEEPSEEK_BASE_URL", scope: "provider", placeholder: "https://api.deepseek.com" },
@@ -1180,6 +1211,7 @@ const LOGIN_FIELD_DEFINITIONS = {
 const DEPRECATED_MODEL_ENV_KEYS = [
     "MODEL_API_KEY", "MODEL_BASE_URL", "MODEL_ID", "MODEL_FALLBACK_ID", "MODEL_ENDPOINT", "OPENAI_PROVIDER",
     "OPENAI_REASONING_EFFORT", "OPENAI_REASONING_SUMMARY", "OPENAI_MAX_OUTPUT_TOKENS", "OPENAI_TIMEOUT_MS", "OPENAI_STREAM_IDLE_TIMEOUT_MS", "OPENAI_MAX_RETRIES",
+    "ANTHROPIC_REASONING_EFFORT", "ANTHROPIC_REASONING_SUMMARY", "ANTHROPIC_MAX_OUTPUT_TOKENS", "ANTHROPIC_TIMEOUT_MS", "ANTHROPIC_STREAM_IDLE_TIMEOUT_MS", "ANTHROPIC_MAX_RETRIES",
     "DEEPSEEK_REASONING_EFFORT", "DEEPSEEK_REASONING_SUMMARY", "DEEPSEEK_MAX_OUTPUT_TOKENS", "DEEPSEEK_TIMEOUT_MS", "DEEPSEEK_STREAM_IDLE_TIMEOUT_MS", "DEEPSEEK_MAX_RETRIES",
     "KIMI_REASONING_EFFORT", "KIMI_REASONING_SUMMARY", "KIMI_MAX_OUTPUT_TOKENS", "KIMI_TIMEOUT_MS", "KIMI_STREAM_IDLE_TIMEOUT_MS", "KIMI_MAX_RETRIES",
     "MOONSHOT_REASONING_EFFORT", "MOONSHOT_REASONING_SUMMARY", "MOONSHOT_MAX_OUTPUT_TOKENS", "MOONSHOT_TIMEOUT_MS", "MOONSHOT_STREAM_IDLE_TIMEOUT_MS", "MOONSHOT_MAX_RETRIES",
@@ -1218,9 +1250,13 @@ function guessLoginProvider(env) {
         return "kimi";
     if (env.DEEPSEEK_API_KEY ?? process.env.DEEPSEEK_API_KEY)
         return "deepseek";
+    if (env.ANTHROPIC_API_KEY ?? process.env.ANTHROPIC_API_KEY)
+        return "anthropic";
     return currentModelProvider();
 }
 function defaultBaseUrlForLoginProvider(provider) {
+    if (provider === "anthropic")
+        return "https://api.anthropic.com";
     if (provider === "deepseek")
         return "https://api.deepseek.com";
     if (provider === "kimi")
@@ -1228,6 +1264,8 @@ function defaultBaseUrlForLoginProvider(provider) {
     return "https://api.openai.com";
 }
 function defaultModelForLoginProvider(provider) {
+    if (provider === "anthropic")
+        return "claude-sonnet-4-6";
     if (provider === "deepseek")
         return "deepseek-chat";
     if (provider === "kimi")
@@ -1288,6 +1326,8 @@ function stripEnvQuotes(value) {
     return value;
 }
 function modelEnvKeyForProvider(provider) {
+    if (provider === "anthropic")
+        return "ANTHROPIC_MODEL";
     if (provider === "deepseek")
         return "DEEPSEEK_MODEL";
     if (provider === "kimi")
@@ -1844,7 +1884,7 @@ function truncate(value, maxLength) {
 function estimateTokens(text) {
     return text ? Math.max(1, Math.ceil(text.length / 4)) : 0;
 }
-function formatUsageTotals(totals) {
+function formatWebUsageTotals(totals) {
     const totalLabel = totals.computedTotalTokens ? "Total tokens (computed)" : "Total tokens";
     return [
         "Session usage:",
@@ -1859,12 +1899,12 @@ function formatUsageTotals(totals) {
 function formatManualCompaction(result) {
     if (!result.changed)
         return "No context compaction was needed.";
-    return `context compacted: ${result.messages.length} message(s) retained, ${formatNumber(result.tokensFreed ?? 0)} chars removed`;
+    return `context compacted: ${result.messages.length} message(s) retained, ${formatNumber(result.charsFreed ?? result.tokensFreed ?? 0)} chars removed`;
 }
 function formatPureCompaction(result) {
     if (!result.changed)
         return "No context available to purify.";
-    return `pure context compacted: ${result.messages.length} sanitized message(s) retained, ${formatNumber(result.tokensFreed ?? 0)} chars removed; raw command/log/code details omitted`;
+    return `pure context compacted: ${result.messages.length} sanitized message(s) retained, ${formatNumber(result.charsFreed ?? result.tokensFreed ?? 0)} chars removed; raw command/log/code details omitted`;
 }
 function formatNumber(value) {
     return value === undefined ? "?" : new Intl.NumberFormat("en-US").format(Math.round(value));