@orbit-intelligence/orbit-agent 0.3.14 → 0.3.16

package/dist/prompts/system.js

@@ -23,6 +23,12 @@ ${extras.conventions}`
 When a user request matches one of these skills, load its instructions before starting. To load a skill body your model can call the \`load_project_skill\` tool; use the skill's name exactly as listed.
 ${extras.skills.map((s) => `- \`${s.name}\` — ${s.summary}`).join('\n')}`
         : '';
+    const memoryBlock = extras?.memory && extras.memory.trim().length > 0
+        ? `
+# Persistent memory
+Facts the user asked you to remember across sessions (MEMORY.md). Treat these as durable context; update them only via the /remember command or explicit user request.
+${extras.memory.trim()}`
+        : '';
     return `You are orbit-agent, an interactive terminal agent for software engineering tasks. You help users safely and efficiently, using the tools below and following these instructions strictly.
 
 # Operating environment
@@ -33,6 +39,7 @@ ${extras.skills.map((s) => `- \`${s.name}\` — ${s.summary}`).join('\n')}`
 ${termuxBlock}
 ${conventionsBlock}
 ${skillsBlock}
+${memoryBlock}
 
 # Core mandates
 - Conventions: Rigorously adhere to existing project conventions when reading or modifying code. Analyze surrounding code, tests, and configuration first.

package/dist/src/cli/orchestrate.js

@@ -37,7 +37,13 @@ export async function runOrchestrateCmd(opts) {
         toolTimeoutMs: config.tools?.timeoutMs ?? 30_000,
         streamTimeoutMs: config.runtime?.streamTimeoutMs ?? 120_000,
     };
-    const registry = new ToolRegistry({ cwd, canWrite: true, shell: config.tools.shell });
+    const registry = new ToolRegistry({
+        cwd,
+        canWrite: true,
+        shell: config.tools.shell,
+        filesystem: config.tools.filesystem,
+        search: config.tools.search,
+    });
     registerOrchestrationTools(registry);
     const app = new TuiApp({
         config,

package/dist/src/cli/run.js

@@ -5,7 +5,7 @@ import { VERSION } from '../version.js';
 import { touchConfig, saveConfig } from '../config/index.js';
 import { EventBus } from '../core/events.js';
 import { buildProviders, resolveCandidates } from '../core/llm/index.js';
-import { resolvePickerRows } from '../tui/picker.js';
+import { resolveModelRows, resolveProviderRows } from '../tui/picker.js';
 import { AutoRouter } from '../core/llm/router.js';
 import { ContextManager } from '../core/context/context-manager.js';
 import { ToolRegistry } from '../core/tools/registry.js';
@@ -17,8 +17,9 @@ import { hasAnySecrets } from '../core/llm/secrets.js';
 import { runWizard } from '../setup/wizard.js';
 import { createSession, saveSession, pruneSessions } from '../session/store.js';
 import { createEventLog, appendEvent, readEventLog } from '../session/event-log.js';
-import { loadProjectContext } from '../core/project-context.js';
+import { loadProjectContext, appendProjectMemory } from '../core/project-context.js';
 import { createSkillLoaderTool } from '../core/skill-loader.js';
+import { newMessage } from '../core/types.js';
 const THEME_NAMES = ['tokyonight', 'catppuccin-mocha', 'catppuccin-latte', 'nord', 'gruvbox', 'monokai', 'clean-dark'];
 const PROVIDER_IDS = ['orbitx', 'groq', 'gemini', 'openrouter', 'openai', 'anthropic', 'grok', 'deepseek', 'ollama'];
 export async function main(argv) {
@@ -135,14 +136,16 @@ export async function main(argv) {
         console.error(`⚠  No models available for routing.\n    ${tip}\n`);
         return 1;
     }
-    // Project context: AGENTS.md conventions + .orbit/skills. Injected into the
-    // system prompt; skills exposed both to the model (load_project_skill) and
-    // the /skills command.
-    const project = loadProjectContext(cwd);
-    const systemPrompt = buildSystemPrompt(cfg, cwd, {
+    // Project context: AGENTS.md conventions + MEMORY.md + .orbit/skills.
+    // Injected into the system prompt; skills exposed both to the model
+    // (load_project_skill) and the /skills command.
+    let project = loadProjectContext(cwd);
+    const buildPrompt = () => buildSystemPrompt(cfg, cwd, {
         conventions: project.conventions,
+        memory: project.memory,
         skills: project.skills.map((s) => ({ name: s.name, summary: s.summary })),
     });
+    let systemPrompt = buildPrompt();
     if (args.orchestrate) {
         const { runOrchestrateCmd } = await import('./orchestrate.js');
         return runOrchestrateCmd({
@@ -154,7 +157,13 @@ export async function main(argv) {
         });
     }
     const context = new ContextManager(systemPrompt);
-    const registry = new ToolRegistry({ cwd, canWrite: true, shell: cfg.tools.shell });
+    const registry = new ToolRegistry({
+        cwd,
+        canWrite: true,
+        shell: cfg.tools.shell,
+        filesystem: cfg.tools.filesystem,
+        search: cfg.tools.search,
+    });
     let session = createSession(new Date().toLocaleString(), cwd);
     if (args.session) {
         const { loadSession } = await import('../session/store.js');
@@ -212,6 +221,25 @@ export async function main(argv) {
                 cfg.permissions.mode = 'allow';
                 saveConfig(cfg);
                 return null;
+            case 'remember': {
+                const note = cmd.value?.trim();
+                if (!note)
+                    return 'Usage: /remember <note>';
+                const path = appendProjectMemory(cwd, note);
+                if (path === null)
+                    return 'Could not write MEMORY.md.';
+                // Reload memory and refresh the live system prompt without a restart.
+                project = loadProjectContext(cwd);
+                systemPrompt = buildPrompt();
+                context.setSystemPrompt(systemPrompt);
+                return `Remembered → ${path}`;
+            }
+            case 'compact': {
+                if (context.history().length === 0)
+                    return 'Nothing to compact yet.';
+                const result = await compactContext(bus, router, context, cfg.agent.contextBudgetTokens);
+                return result;
+            }
             default:
                 return null;
         }
@@ -248,7 +276,7 @@ export async function main(argv) {
         onCommand,
         version: VERSION,
         models: router.order(),
-        pickRows: () => resolvePickerRows(),
+        pickRows: (stage, providerId, liveModels) => stage === 'providers' ? Promise.resolve(resolveProviderRows()) : resolveModelRows(providerId ?? '', liveModels),
     });
     app.store.skills = project.skills.map((s) => ({ name: s.name, summary: s.summary }));
     const resumeMessages = session.messages.filter((m) => m.role !== 'tool');
@@ -329,10 +357,17 @@ async function runSingleShot(cfg, cwd, prompt, autoAllow) {
     const project = loadProjectContext(cwd);
     const systemPrompt = buildSystemPrompt(cfg, cwd, {
         conventions: project.conventions,
+        memory: project.memory,
         skills: project.skills.map((s) => ({ name: s.name, summary: s.summary })),
     });
     const context = new ContextManager(systemPrompt);
-    const registry = new ToolRegistry({ cwd, canWrite: true, shell: cfg.tools.shell });
+    const registry = new ToolRegistry({
+        cwd,
+        canWrite: true,
+        shell: cfg.tools.shell,
+        filesystem: cfg.tools.filesystem,
+        search: cfg.tools.search,
+    });
     registry.register(createSkillLoaderTool(project));
     const permissionMode = autoAllow ? 'allow' : cfg.permissions.mode;
     const permissions = new PermissionManager({ ...cfg.permissions, mode: permissionMode }, { ask: (q) => askConsole(q) });
@@ -399,3 +434,62 @@ function emitRoute(bus, router, cfg) {
         bus.emit('onRoute', { ...firstRoute, strategy: cfg.routing.strategy });
     }
 }
+// ---------------------------------------------------------------------------
+// /compact — summarize the older turns with the model, keep the current turn.
+// ---------------------------------------------------------------------------
+const SUMMARIZE_SYSTEM = `You are a conversation summarizer for a coding-agent session. Produce a terse, structured summary of the conversation transcript you are given: a short Objective, Important Details (exact file paths, command names, and file:line references), Work State (Completed / Active / Blocked), and Next Move. Preserve hard facts verbatim where possible — do not invent state. Keep it under ~400 words. Output only the summary.`;
+/**
+ * Compact the conversation: summarize everything before the current turn via
+ * the router, replace it with a single summary message, and emit
+ * onContextSummary. Falls back to drop-only compaction when the model call
+ * fails or there is nothing to summarize.
+ */
+async function compactContext(bus, router, context, budget) {
+    const { older, current } = context.splitCurrentTurn();
+    if (older.length === 0) {
+        // Single-turn context: nothing older to summarize; drop-only path.
+        const res = context.compact(budget);
+        bus.emit('onContextSummary', res);
+        return res.droppedPairs > 0
+            ? `Compacted (drop-only): dropped ${res.droppedPairs} turns · ${res.tokensBefore} → ${res.tokensAfter} tokens.`
+            : 'Context already fits the budget.';
+    }
+    const tokensBefore = context.estimateTokens();
+    try {
+        const summary = await summarizeWith(router, older);
+        if (summary && summary.trim().length > 0) {
+            const summaryMsg = newMessage(`sum_${Date.now()}`, 'user', summary);
+            context.replaceHistory([summaryMsg, ...current]);
+            const tokensAfter = context.estimateTokens();
+            const droppedPairs = older.filter((m) => m.role === 'user').length;
+            bus.emit('onContextSummary', { droppedPairs, tokensBefore, tokensAfter });
+            return `Compacted with model summary: ${droppedPairs} older turns replaced · ${tokensBefore} → ${tokensAfter} tokens.`;
+        }
+    }
+    catch {
+        // model summarization unavailable — fall through to drop-only
+    }
+    const res = context.compact(budget);
+    bus.emit('onContextSummary', res);
+    return res.droppedPairs > 0
+        ? `Model compact failed; dropped ${res.droppedPairs} turns instead · ${res.tokensBefore} → ${res.tokensAfter} tokens.`
+        : 'Context already fits the budget.';
+}
+/** Stream a structured summary of `older` through the router, returning its text. */
+async function summarizeWith(router, older) {
+    // Peek at the current route so the router streams on the exact active model.
+    const peek = router.peek();
+    if (!peek)
+        throw new Error('no route');
+    const model = `${peek.provider}/${peek.model}`;
+    const sub = new ContextManager(SUMMARIZE_SYSTEM);
+    for (const m of older)
+        sub.add(m);
+    sub.addUser('Summarize the transcript above.');
+    let text = '';
+    for await (const ev of router.stream({ messages: sub.toOutgoing(), model, temperature: 0.2 })) {
+        if (ev.type === 'token')
+            text += ev.text;
+    }
+    return text;
+}

package/dist/src/core/agent/agent-loop.js

@@ -1,3 +1,4 @@
+import { sanitizeToken, sanitizeContent } from '../llm/sanitize.js';
 import { combineSignals } from '../../utils/signals.js';
 import { unifiedDiff, countChanges } from '../../utils/diff.js';
 import { readFile, stat } from 'node:fs/promises';
@@ -87,13 +88,15 @@ export class AgentLoop {
                     try {
                         for await (const ev of gen) {
                             if (ev.type === 'token') {
-                                asstMsg.content += ev.text;
-                                bus.emit('onToken', ev.text);
+                                const clean = sanitizeToken(ev.text);
+                                asstMsg.content += clean;
+                                bus.emit('onToken', clean);
                                 await throttle(this.opts.maxTokensPerSecond);
                             }
                             else if (ev.type === 'reasoning') {
-                                asstMsg.reasoning = (asstMsg.reasoning ?? '') + ev.text;
-                                bus.emit('onThinking', ev.text);
+                                const clean = sanitizeToken(ev.text);
+                                asstMsg.reasoning = (asstMsg.reasoning ?? '') + clean;
+                                bus.emit('onThinking', clean);
                             }
                             else if (ev.type === 'tool_call_start') {
                                 const call = {
@@ -153,6 +156,8 @@ export class AgentLoop {
             // TUI reveal the whole message (snap the typewriter to the end) so the
             // text sits above the tool rows BEFORE the tools start running — the
             // user should see "intent first, then action".
+            asstMsg.content = sanitizeContent(asstMsg.content);
+            asstMsg.reasoning = sanitizeContent(asstMsg.reasoning ?? '');
             bus.emit('onAssistantGenerationDone', asstMsg);
             asstMsg.streaming = false;
             asstMsg.reasoningOpen = (asstMsg.reasoning?.length ?? 0) > 0;
@@ -169,11 +174,17 @@ export class AgentLoop {
                 // don't pollute history, burn a turn slot, and try the model again.
                 continue;
             }
+            // Record the assistant message (with its tool_calls) BEFORE executing the
+            // tools: toOutgoing() pairs each tool result with the assistant turn that
+            // invoked it. Adding it afterwards would walk the results back to the
+            // user message instead (nothing precedes a bare tool message in the wire
+            // history), so the provider would never deliver the file contents. This
+            // ordering bug made read_file/list_dir output invisible to the model.
+            this.opts.context.addAssistant(asstMsg.content, { model: asstMsg.model, toolCalls });
             // Execute each tool call, feed results back into context
             for (const call of toolCalls) {
                 await this.executeTool(call);
             }
-            this.opts.context.addAssistant(asstMsg.content, { model: asstMsg.model, toolCalls });
             bus.emit('onAssistantEnd', asstMsg);
             // Overflow-driven compaction (adapted from opencode's loop protection):
             // after a tool-heavy turn, bring the outgoing context back inside budget
@@ -201,9 +212,19 @@ export class AgentLoop {
             const decision = await this.opts.permissions.checkCommand(parseCommandArg(call.args));
             denied = decision === 'deny';
         }
-        else if (call.name === 'write_file') {
-            const decision = await this.opts.permissions.checkPath(parseWritePath(call.args), 'write');
+        else if (call.name === 'write_file' || call.name === 'edit_file') {
+            const writePath = parseWritePath(call.args);
+            const decision = await this.opts.permissions.checkPath(writePath, 'write');
             denied = decision === 'deny';
+            // Containment: mutating file tools must stay inside the working
+            // directory (or an allowPath) so a model can't `../`-escape the project.
+            if (!denied && writePath) {
+                const resolved = resolveCwdPath(writePath, this.opts.cwd ?? '');
+                const cwdRoot = resolve(this.opts.cwd ?? '.');
+                const inCwd = pathWithin(resolved, cwdRoot);
+                const inAllowed = this.opts.permissions.allowPaths.some((a) => pathWithin(resolved, resolveCwdPath(a, this.opts.cwd ?? '.')));
+                denied = !inCwd && !inAllowed;
+            }
         }
         else if (MUTATING_TOOLS[call.name]) {
             const decision = await this.opts.permissions.checkCommand(MUTATING_TOOLS[call.name]);
@@ -363,6 +384,12 @@ function resolveCwdPath(p, cwd) {
         return p;
     return resolve(cwd, p);
 }
+/** True when `candidate` is `root` or a descendant of it (path-sealed). */
+export function pathWithin(candidate, root) {
+    const c = resolve(candidate);
+    const r = resolve(root);
+    return c === r || c.startsWith(r.endsWith('/') ? r : `${r}/`);
+}
 async function captureSnapshot(args, cwd, toolName) {
     if (toolName !== 'edit_file' && toolName !== 'write_file')
         return null;

package/dist/src/core/context/context-manager.js

@@ -59,12 +59,25 @@ export class ContextManager {
             }
             if (m.role === 'tool') {
                 const tr = m;
-                let last = out[out.length - 1];
-                // find the preceding assistant turn
-                let idx = out.length - 1;
-                while (idx >= 0 && out[idx].role !== 'assistant')
-                    idx--;
-                last = out[idx] ?? out[out.length - 1];
+                // Pair the result with the assistant turn that declared its tool call:
+                // prefer the nearest preceding assistant whose toolCalls carries this
+                // toolCallId (never a bare user/system message). Falls back to the most
+                // recent assistant when an id is missing (legacy/compacted history).
+                let last;
+                for (let idx = out.length - 1; idx >= 0; idx--) {
+                    const cand = out[idx];
+                    if (cand.role !== 'assistant')
+                        continue;
+                    last = cand;
+                    if (tr.toolCallId) {
+                        const declared = (cand.toolCalls ?? []).some((tc) => tc.id === tr.toolCallId);
+                        if (declared)
+                            break;
+                    }
+                    else {
+                        break;
+                    }
+                }
                 if (last && tr.toolCallId) {
                     const existing = last.toolResults ?? [];
                     last.toolResults = [
@@ -164,4 +177,25 @@ export class ContextManager {
         }
         return Math.ceil(chars / 4) + count;
     }
+    /**
+     * Split history into the current (newest) turn — the last user message and
+     * everything after it — and the older turns. Used by /compact to summarize
+     * the older portion while keeping the active turn verbatim.
+     */
+    splitCurrentTurn() {
+        let lastUser = -1;
+        for (let i = this.messages.length - 1; i >= 0; i--) {
+            if (this.messages[i]?.role === 'user') {
+                lastUser = i;
+                break;
+            }
+        }
+        if (lastUser < 0)
+            return { older: [], current: this.messages };
+        return { older: this.messages.slice(0, lastUser), current: this.messages.slice(lastUser) };
+    }
+    /** Replace the whole history (used by /compact to inject the summary). */
+    replaceHistory(messages) {
+        this.messages = messages;
+    }
 }

package/dist/src/core/llm/endpoints.js

@@ -0,0 +1,110 @@
+/**
+ * Custom OpenAI-compatible endpoint registry.
+ *
+ * Lets users add named endpoints (LM Studio, vLLM, a personal gateway, …)
+ * with a base URL and an OPTIONAL key. Persisted to the git-ignored
+ * `endpoints.json` (0600) next to keys.json. Base URLs are not secrets, but
+ * endpoint keys are — keeping both in one 0600 file matches the keys.json
+ * security posture (never config.json).
+ */
+import { readFileSync, existsSync, chmodSync, mkdirSync, writeFileSync } from 'node:fs';
+import { endpointsPath, configDir } from '../../utils/platform.js';
+const CACHE_MS = 2000;
+let cache = null;
+function readFile() {
+    const now = Date.now();
+    if (cache && now - cache.at < CACHE_MS)
+        return cache.data;
+    const path = endpointsPath();
+    if (!existsSync(path)) {
+        cache = { data: [], at: now };
+        return [];
+    }
+    try {
+        const raw = JSON.parse(readFileSync(path, 'utf8'));
+        if (!Array.isArray(raw))
+            throw new Error('not an array');
+        const cleaned = raw.filter((e) => e && typeof e.name === 'string' && typeof e.baseUrl === 'string');
+        cache = { data: cleaned, at: now };
+        return cleaned;
+    }
+    catch {
+        cache = { data: [], at: now };
+        return [];
+    }
+}
+function write(list) {
+    mkdirSync(configDir(), { recursive: true });
+    writeFileSync(endpointsPath(), JSON.stringify(list, null, 2), 'utf8');
+    try {
+        chmodSync(endpointsPath(), 0o600);
+    }
+    catch {
+        /* best-effort */
+    }
+    cache = { data: list, at: Date.now() };
+}
+export function loadEndpoints() {
+    return readFile();
+}
+export function findEndpoint(name) {
+    return readFile().find((e) => e.name === name) ?? null;
+}
+/** Upsert by name (case-sensitive). Returns an error string, or null on success. */
+export function saveEndpoint(ep) {
+    const trimmed = { ...ep, name: ep.name.trim(), baseUrl: ep.baseUrl.trim() };
+    if (!/^[a-z0-9][a-z0-9._-]{0,39}$/.test(trimmed.name)) {
+        return 'name must be 1-40 chars: lowercase letters, digits, . _ -';
+    }
+    if (!/^https?:\/\/\S+$/.test(trimmed.baseUrl)) {
+        return 'base URL must start with http:// or https://';
+    }
+    if (!trimmed.baseUrl.endsWith('/v1') && !/\/(v1|v1beta1)\/?$/.test(trimmed.baseUrl)) {
+        trimmed.baseUrl = `${trimmed.baseUrl.replace(/\/+$/, '')}/v1`;
+    }
+    const list = readFile();
+    const idx = list.findIndex((e) => e.name === trimmed.name);
+    if (idx >= 0)
+        list[idx] = trimmed;
+    else
+        list.push(trimmed);
+    write(list);
+    return null;
+}
+export function deleteEndpoint(name) {
+    write(readFile().filter((e) => e.name !== name));
+}
+/** Remember a model id the user actually picked for this endpoint. */
+export function rememberEndpointModel(name, model) {
+    const list = readFile();
+    const ep = list.find((e) => e.name === name);
+    if (!ep)
+        return;
+    const models = ep.models ?? [];
+    if (!models.includes(model)) {
+        ep.models = [...models, model].slice(-20);
+        write(list);
+    }
+}
+/** Probe the endpoint's live /v1/models list (fast-fail, short timeout). */
+export async function listEndpointModels(name) {
+    const ep = findEndpoint(name);
+    if (!ep)
+        return [];
+    try {
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(new Error('endpoint probe timed out')), 3000);
+        const headers = { accept: 'application/json' };
+        if (ep.key)
+            headers.authorization = `Bearer ${ep.key}`;
+        const res = await fetch(`${ep.baseUrl.replace(/\/+$/, '')}/models`, { signal: ctrl.signal, headers });
+        clearTimeout(timer);
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const json = (await res.json());
+        return (json.data ?? []).map((m) => m.id).filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/src/core/llm/index.js

@@ -3,6 +3,7 @@ import { createOpenAiProvider } from './providers/openai-compat.js';
 import { createGeminiProvider } from './providers/gemini.js';
 import { createAnthropicProvider } from './providers/anthropic.js';
 import { createOllamaProvider } from './providers/ollama.js';
+import { loadEndpoints } from './endpoints.js';
 import { PROVIDER_CATALOGS, ORBITX_SERVE, modelsOf } from './models.js';
 export { PROVIDER_CATALOGS as PROVIDER_SPECS, ORBITX_SERVE, modelsOf };
 const ENDPOINTS = {
@@ -65,6 +66,21 @@ export function buildProviders(config) {
     }
     // Local Ollama is always offered: no key required, auto-detects the server.
     providers.ollama = createOllamaProvider();
+    // Named custom OpenAI-compatible endpoints (endpoints.json). Each is exposed
+    // as a provider keyed by its name so `<name>/<model>` routes to it.
+    for (const ep of loadEndpoints()) {
+        if (!ep || !ep.name || !ep.baseUrl)
+            continue;
+        const existing = providers[ep.name];
+        if (existing)
+            continue; // never shadow a real provider with a same-named endpoint
+        providers[ep.name] = createOpenAiProvider({
+            id: ep.name,
+            baseUrl: ep.baseUrl,
+            apiKey: ep.key ?? '',
+            models: (ep.models ?? []).filter(Boolean),
+        });
+    }
     return providers;
 }
 /** Candidate model ids (provider-prefixed) for the router. */

package/dist/src/core/llm/sanitize.js

@@ -0,0 +1,47 @@
+/**
+ * Streamed-content sanitizer.
+ *
+ * Some gateway models (gpt-oss family, Qwen cloud variants) leak control
+ * tokens into the visible content stream: `<|start|>functions.list_dir
+ * to=assistant<|message|>{...}` pensieve blocks, dangling `<|...|>` tags,
+ * and boundary boilerplate such as a lone `response` line or "Proceed to
+ * final answer." Strip those before the TUI renders or history commits them
+ * so the user sees the prose, not the plumbing.
+ */
+/** Control-rune tag, e.g. `<|start|>`, `<|message|>`, `<|end|>`. */
+const TAG_RE = /<\|[^|>]*\|>/g;
+/**
+ * Qwen/OSS pensieve header: `<|start|>functions.<name> to=assistant
+ * <|message|>` followed by a mangled JSON echo that model emits verbatim.
+ * Removes the header plus the leading portion of the echoed line up to the
+ * first blank line, which is where the real prose begins in practice.
+ */
+const PENSIVE_RE = /<\|start\|>\n?[\s\S]*?<\|message\|>[ \t]*[^\r\n]*\n/g;
+/** Lone boundary markers some cloud models insert before their answer. */
+const BOUNDARY_LINE_RE = /^[ \t]*(?:response|Proceed to final answer\.?)[ \t]*$/gm;
+/** Collapse 3+ consecutive blank lines down to two (post-strip tidy-up). */
+const BLANK_RUN_RE = /\n{3,}/g;
+/**
+ * Sanitize a single streamed token. idempotent; cheap enough to run per
+ * token. A `<|` opened mid-chunk but closed later is finished by
+ * `sanitizeContent` over the assembled text, so partial matches here are
+ * fine.
+ */
+export function sanitizeToken(text) {
+    let s = text.replace(PENSIVE_RE, '').replace(TAG_RE, '');
+    if (s.includes('response') || s.includes('Proceed to final answer')) {
+        s = s.replace(BOUNDARY_LINE_RE, '');
+    }
+    return s;
+}
+/** Sanitize a fully-assembled message/reasoning blob. */
+export function sanitizeContent(text) {
+    let s = text
+        .replace(PENSIVE_RE, '')
+        .replace(TAG_RE, '')
+        .replace(BOUNDARY_LINE_RE, '')
+        .replace(BLANK_RUN_RE, '\n\n')
+        .replace(/^\n+/, '')
+        .replace(/\n+$/, '');
+    return s;
+}

package/dist/src/core/llm/secrets.js

@@ -83,8 +83,9 @@ export function getProviderSecrets(provider) {
         return { provider, keys: envKeys, source: 'env' };
     const file = readKeysFile();
     const fileKeys = file[provider] ?? [];
-    if (fileKeys.length > 0)
-        return { provider, keys: fileKeys, source: 'file' };
+    const flat = fileKeys.map((k) => (typeof k === 'string' ? k : k.key)).filter(Boolean);
+    if (flat.length > 0)
+        return { provider, keys: flat, source: 'file' };
     return null;
 }
 export function hasAnySecrets() {
@@ -108,12 +109,30 @@ export function describeProvidersAvailable() {
     }
     return out;
 }
+export function describeProviderKey(provider) {
+    const s = getProviderSecrets(provider);
+    if (!s || !s.keys[0])
+        return { provider, available: false };
+    const named = readKeysFile()[provider]?.find((k) => typeof k === 'object');
+    return {
+        provider,
+        available: true,
+        masked: maskSecret(s.keys[0]),
+        source: s.source,
+        label: named?.name,
+    };
+}
 /**
  * Persist provider keys to the git-ignored keys.json (0600), merging over any
  * existing keys so a re-run of the wizard never wipes other providers.
  */
 export function writeKeys(provider, keys) {
-    const trimmed = keys.map((k) => k.trim()).filter(Boolean);
+    const trimmed = keys
+        .map((k) => {
+        const key = typeof k === 'string' ? k.trim() : { name: k.name.trim() || 'default', key: k.key.trim() };
+        return typeof key === 'string' ? key : { name: key.name, key: key.key };
+    })
+        .filter((k) => (typeof k === 'string' ? k : k.key) !== '');
     if (trimmed.length === 0)
         return 'no keys provided';
     const existing = readKeysFile();
@@ -129,3 +148,42 @@ export function writeKeys(provider, keys) {
         return err.message;
     }
 }
+/** Save (or update by label) a single named key for a provider. */
+export function saveNamedKey(provider, name, key) {
+    const clean = key.trim();
+    if (!clean)
+        return 'no key provided';
+    const label = name.trim() || 'default';
+    const existing = readKeysFile();
+    const list = existing[provider] ?? [];
+    const idx = list.findIndex((k) => typeof k === 'object' && k.name === label);
+    if (idx >= 0)
+        list[idx] = { name: label, key: clean };
+    else
+        list.push({ name: label, key: clean });
+    existing[provider] = list;
+    try {
+        mkdirSync(configDir(), { recursive: true });
+        writeFileSync(keysPath(), JSON.stringify(existing, null, 2), 'utf8');
+        chmodSync(keysPath(), 0o600);
+        invalidateKeysCache();
+        return null;
+    }
+    catch (err) {
+        return err.message;
+    }
+}
+/** Human "masked · source [label]" description for a provider's configured key. */
+export function describeKey(provider) {
+    const envKeys = fromEnv(provider);
+    if (envKeys.length > 0 && envKeys[0])
+        return { masked: maskSecret(envKeys[0]), source: 'env' };
+    const file = readKeysFile();
+    const entries = file[provider] ?? [];
+    const first = entries[0];
+    if (!first)
+        return null;
+    if (typeof first === 'string')
+        return { masked: maskSecret(first), source: 'file' };
+    return { masked: maskSecret(first.key), source: 'file', label: first.name };
+}