@orbit-intelligence/orbit-agent 0.3.15 → 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

@@ -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;
         }
@@ -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

@@ -174,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
@@ -206,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]);
@@ -368,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/project-context.js

@@ -1,4 +1,4 @@
-import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { readFileSync, readdirSync, statSync, mkdirSync, writeFileSync } from 'node:fs';
 import { resolve, dirname, join, basename } from 'node:path';
 /**
  * Project-scoped instruction loading, modeled on Agent Build / Claude Code:
@@ -14,6 +14,10 @@ import { resolve, dirname, join, basename } from 'node:path';
  */
 const CONVENTION_FILES = ['AGENTS.md', '.orbit/AGENTS.md', '.agents/AGENTS.md', 'CLAUDE.md'];
 const MAX_TOTAL_BYTES = 120_000;
+/** Files holding long-term memory (read once at startup, editable via /remember). */
+const MEMORY_FILES = ['MEMORY.md', '.orbit/MEMORY.md'];
+/** Cap for injected memory, ~25KB; /remember bounds appends to this. */
+const MAX_MEMORY_BYTES = 25_000;
 export function loadProjectContext(cwd) {
     const files = [];
     const bodies = [];
@@ -34,6 +38,7 @@ export function loadProjectContext(cwd) {
         }
         return total > MAX_TOTAL_BYTES;
     });
+    const { memory, memoryFile } = loadMemory(cwd);
     const skillsDir = findSkillsDir(cwd);
     const skillBodies = {};
     const skills = [];
@@ -52,7 +57,62 @@ export function loadProjectContext(cwd) {
         }
         skills.sort((a, b) => a.name.localeCompare(b.name));
     }
-    return { files, conventions: bodies.join('\n'), skills, skillBodies };
+    return { files, conventions: bodies.join('\n'), memory, memoryFile, skills, skillBodies };
+}
+/**
+ * Locate memory files walking up from cwd (lowest dir wins), concatenating in
+ * order. Capped at MAX_MEMORY_BYTES like conventions but separately, so a blob
+ * of memory never eats the AGENTS.md budget.
+ */
+function loadMemory(cwd) {
+    const found = [];
+    collectUpward(cwd, (dir) => {
+        for (const name of MEMORY_FILES) {
+            const p = join(dir, name);
+            if (found.some((f) => f.p === p))
+                continue;
+            const raw = readSafe(p);
+            if (raw === null)
+                continue;
+            found.push({ p, raw });
+        }
+        return false;
+    });
+    if (found.length === 0)
+        return { memory: '', memoryFile: null };
+    let memory = '';
+    for (const { p, raw } of found) {
+        memory += `## ${relLabel(p, cwd)}\n${raw.trim()}\n\n`;
+        if (memory.length > MAX_MEMORY_BYTES)
+            break;
+    }
+    return { memory: memory.slice(0, MAX_MEMORY_BYTES), memoryFile: found[0].p };
+}
+/**
+ * Append a note to the project's memory file (/remember). Creates MEMORY.md in
+ * cwd when none exists. Returns the file path written, or null on failure.
+ */
+export function appendProjectMemory(cwd, note) {
+    const target = resolve(cwd, 'MEMORY.md');
+    const existing = readSafe(target) ?? '';
+    const header = existing.trim().length > 0 ? '' : '# orbit memory\n';
+    let body = existing + (existing.endsWith('\n') ? '' : '\n') + `- ${new Date().toISOString().slice(0, 10)}: ${note.trim()}\n`;
+    if (body.length > MAX_MEMORY_BYTES) {
+        // Keep the newest notes: drop the oldest lines until under cap.
+        const lines = body.split('\n');
+        while (body.length > MAX_MEMORY_BYTES && lines.length > 4) {
+            lines.shift();
+            body = lines.join('\n');
+        }
+    }
+    try {
+        mkdirSync(dirname(target), { recursive: true });
+        writeFileSync(target, header + body, 'utf8');
+        return target;
+    }
+    catch {
+        return null;
+    }
 }
 function collectUpward(start, visit) {
     let dir = resolve(start);

package/dist/src/core/tools/registry.js

@@ -15,12 +15,16 @@ export class ToolRegistry {
     ctx;
     constructor(init) {
         this.ctx = { cwd: init.cwd, canWrite: init.canWrite ?? true };
-        this.register(readFileTool);
-        this.register(editFileTool);
-        this.register(writeFileTool);
-        this.register(listDirTool);
-        this.register(globTool);
-        this.register(grepTool);
+        if (init.filesystem ?? true) {
+            this.register(readFileTool);
+            this.register(editFileTool);
+            this.register(writeFileTool);
+            this.register(listDirTool);
+            this.register(globTool);
+        }
+        if (init.search ?? true) {
+            this.register(grepTool);
+        }
         if (init.withGit ?? true) {
             for (const t of gitTools)
                 this.register(t);

package/dist/src/tui/app.js

@@ -247,6 +247,18 @@ export class TuiApp {
             }
             this.store.refresh();
         });
+        // Automatic context compaction happened (agent loop) — surface it.
+        this.bus.on('onContextSummary', ({ droppedPairs, tokensBefore, tokensAfter }) => {
+            this.store.contextTokens = tokensAfter;
+            this.pushMessage({
+                id: `ctx-${Date.now()}`,
+                role: 'system',
+                content: droppedPairs > 0
+                    ? `Context compacted: dropped ${droppedPairs} older turns (${tokensBefore} → ${tokensAfter} tokens).`
+                    : `Context within budget (${tokensAfter} tokens).`,
+                createdAt: Date.now(),
+            });
+        });
         // Plan mode lifecycle.
         this.bus.on('onPlanProposed', ({ text }) => {
             const plan = this.store.plan;
@@ -909,6 +921,8 @@ export class TuiApp {
                         `/diff            toggle unified diff view (or press d)`,
                         `/skills          list project skills (AGENTS.md / .orbit/skills)`,
                         `/theme <name>    change theme (${THEME_NAMES.join(' · ')})`,
+                        `/compact         summarize old context to free budget`,
+                        `/remember <note>  save a fact to MEMORY.md`,
                         `/yolo            auto-approve tools`,
                         `/yes             answer a permission prompt`,
                         `/agents          toggle agent dock (orchestrate mode)`,
@@ -1007,6 +1021,30 @@ export class TuiApp {
                 store.yolo = true;
                 this.note('Permission mode → allow (yolo).');
                 return;
+            case 'compact': {
+                if (store.streaming) {
+                    this.note('Wait for the current turn to finish.');
+                    return;
+                }
+                this.note('Compacting context…');
+                const result = await this.onCommand({ type: 'compact' });
+                if (result) {
+                    store.contextTokens = parseTokenCount(result);
+                    this.note(result);
+                }
+                else
+                    this.note('Nothing to compact.');
+                return;
+            }
+            case 'remember': {
+                if (!arg) {
+                    this.note('Usage: /remember <note> — save a durable fact to MEMORY.md.');
+                    return;
+                }
+                const result = await this.onCommand({ type: 'remember', value: arg });
+                this.note(result ?? 'Saved to memory.');
+                return;
+            }
             case 'yes':
                 if (store.pendingAsk) {
                     const { resolve } = store.pendingAsk;
@@ -1095,3 +1133,8 @@ function truncateForNote(text, max = 60) {
     const t = text.replace(/\s+/g, ' ').trim();
     return t.length <= max ? t : `${t.slice(0, max)}…`;
 }
+/** Pull the trailing "N tokens" value out of a /compact result message. */
+function parseTokenCount(result) {
+    const m = result.match(/(\d+) tokens?\.?$/);
+    return m ? Number(m[1]) : null;
+}

package/dist/src/tui/components/Header.js

@@ -19,5 +19,5 @@ export function Header({ width }) {
     const border = store.theme ? themeColor(store.theme, 'border') : '#565f89';
     const model = store.route ? `${store.route.provider}/${store.route.model}` : 'no route';
     const dir = shortPath(store.cwd || process.cwd());
-    return (_jsxs(Box, { width: width, borderStyle: "single", borderColor: border, flexDirection: "column", paddingX: 1, children: [_jsxs(Box, { height: 1, children: [_jsx(Text, { color: accent, bold: true, wrap: "truncate-end", children: '>_ orbit' }), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: ` (v${store.version})` }), _jsx(Text, { color: muted, wrap: "truncate-end", children: `   model: ${model}` }), _jsx(Text, { color: dim, wrap: "truncate-end", children: '   /model' })] }), _jsx(Box, { height: 1, children: _jsx(Text, { color: dim, wrap: "truncate-end", children: `directory: ${dir}` }) })] }));
+    return (_jsxs(Box, { width: width, borderStyle: "single", borderColor: border, flexDirection: "column", paddingX: 1, children: [_jsxs(Box, { height: 1, children: [_jsx(Text, { color: accent, bold: true, wrap: "truncate-end", children: '>_ orbit' }), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: ` (v${store.version})` }), _jsx(Text, { color: muted, wrap: "truncate-end", children: `   model: ${model}` }), _jsx(Text, { color: dim, wrap: "truncate-end", children: '   /model' })] }), _jsxs(Box, { height: 1, children: [_jsx(Text, { color: dim, wrap: "truncate-end", children: `directory: ${dir}` }), store.contextTokens !== null && (_jsx(Text, { color: muted, wrap: "truncate-end", children: `   context: ${store.contextTokens} tok` }))] })] }));
 }

package/dist/src/tui/store.js

@@ -10,6 +10,8 @@ const SLASH_COMMANDS = [
     { cmd: '/model', desc: '[id]  select model' },
     { cmd: '/provider', desc: '<id>  switch provider' },
     { cmd: '/theme', desc: '<name>  switch theme' },
+    { cmd: '/compact', desc: 'summarize old context to free budget' },
+    { cmd: '/remember', desc: '<note>  save a fact to MEMORY.md' },
     { cmd: '/plan', desc: '<task>  propose a plan (approve with /run)' },
     { cmd: '/run', desc: 'execute the proposed plan' },
     { cmd: '/skills', desc: 'list project skills' },
@@ -32,6 +34,8 @@ export class AppStore {
     pendingAsk = null;
     inputTokens = 0;
     outputTokens = 0;
+    /** Estimated context size after the last compaction (tokens). */
+    contextTokens = null;
     scrollOffset = 0;
     cancelArmed = false;
     greeted = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbit-intelligence/orbit-agent",
-  "version": "0.3.15",
+  "version": "0.3.16",
   "description": "orbit — a premium pure-TypeScript coding agent for Termux and desktop terminals, powered by Orbit X.",
   "type": "module",
   "license": "UNLICENSED",