jaitus 0.3.6 → 0.3.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jaitus",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "description": "Jaitus — a coding agent in your terminal.",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "node": ">=20"
   },
   "scripts": {
-    "test": "node tests/source-sanity.js && node tests/rules.js && node tests/run.js && node tests/commands.js && node tests/login.js && node tests/session.js && node tests/openUrl.js && node tests/ink-tui.js && node tests/tui-render.js && node tests/mouse-e2e.js && node tests/environment.js && node tests/update.js && node tests/continuation.js && node tests/steps.js && node tests/files.js && node tests/processes.js && node tests/security.js && node tests/context-budget.js",
+    "test": "node tests/source-sanity.js && node tests/rules.js && node tests/run.js && node tests/commands.js && node tests/login.js && node tests/session.js && node tests/openUrl.js && node tests/ink-tui.js && node tests/tui-render.js && node tests/mouse-e2e.js && node tests/environment.js && node tests/update.js && node tests/continuation.js && node tests/steps.js && node tests/files.js && node tests/processes.js && node tests/security.js && node tests/context-budget.js && node tests/context-trim.js",
     "preview": "node scripts/tui-preview.js",
     "prepublishOnly": "npm test"
   },

package/src/agent/loop.js

@@ -106,6 +106,9 @@ How to work:
 - Run the project's own tests or build after a change when one exists, and report the real result — including when it fails.
 - Use run_command for anything the shell does better: git, tests, package managers, linters.
 - Never invent a file path, a function name, or a test result. If you are unsure, look.
+- Every turn re-sends the whole conversation, so make independent reads, searches and
+  listings together in ONE turn rather than one per turn. Read the part of a large file you
+  need (offset/limit) rather than all of it.
 - For current news or other web facts, report only details grounded in web_search or
   web_fetch output. Include the supplied source URLs; never fill a missing headline or
   date from memory.
@@ -229,6 +232,69 @@ export function repairToolPairs(messages) {
   return messages;
 }
 
+// ── Keeping the conversation small ────────────────────────────────────────────
+//
+// Every request re-sends the whole conversation, and in real use that re-send — cached,
+// but not free — was ~75% of what a session cost: 109 requests averaged 46k tokens of
+// context each, most of it tool output from many steps ago (a file read at step 3 is
+// still paid for at step 60). This is the documented "clear old tool results" strategy
+// (Anthropic's context editing, clear_tool_uses; Claude Code's micro-compaction): once
+// the conversation passes TRIM_AT, the outputs of all but the KEEP_RECENT latest tool
+// calls are replaced with a line saying they were cleared and can be re-run. It clears
+// at least TRIM_AT_LEAST at a time, because each clearing breaks the prompt cache once
+// — clearing a little on every step would cost more than it saves. Small results (a
+// "file written", an exit code) are kept: they carry meaning and cost nothing.
+// 100k was the documented default for 200k-window models. Here the window is up to 1M, so
+// that ceiling was rarely near: production requests averaged 53k tokens and two thirds of
+// all input tokens came from requests over 60k. At 40k a clearing (one cache break, ~17
+// credits on glm-5.3-flash) pays for itself within about ten later requests.
+export const TRIM_AT = 40_000;          // estimated tokens of conversation
+export const KEEP_RECENT = 6;           // latest tool results always kept whole
+export const TRIM_AT_LEAST = 12_000;    // estimated tokens a clearing must free
+const TRIM_MIN_CHARS = 1_500;           // results shorter than this are never cleared
+const CLEARED = '[Output cleared';
+
+const blockChars = (b) => {
+  if (b?.type === 'text') return (b.text || '').length;
+  if (b?.type === 'tool_use') return JSON.stringify(b.input || {}).length;
+  if (b?.type === 'tool_result') return typeof b.content === 'string' ? b.content.length : JSON.stringify(b.content || '').length;
+  return 0;
+};
+export function conversationTokens(messages) {
+  let chars = 0;
+  for (const m of messages || []) chars += typeof m?.content === 'string' ? m.content.length : (Array.isArray(m?.content) ? m.content.reduce((n, b) => n + blockChars(b), 0) : 0);
+  return Math.ceil(chars / 4);
+}
+
+/**
+ * Clear old tool outputs in place when the conversation is large. Returns how many
+ * estimated tokens were freed (0 when nothing was worth clearing).
+ */
+export function clearOldToolResults(messages, { at = TRIM_AT, keep = KEEP_RECENT, atLeast = TRIM_AT_LEAST } = {}) {
+  if (conversationTokens(messages) < at) return 0;
+  const names = new Map();
+  for (const m of messages) {
+    if (m?.role === 'assistant' && Array.isArray(m.content)) for (const b of m.content) if (b?.type === 'tool_use') names.set(b.id, b.name);
+  }
+  const results = [];
+  for (const m of messages) {
+    if (m?.role !== 'user' || !Array.isArray(m.content)) continue;
+    m.content.forEach((b, i) => { if (b?.type === 'tool_result') results.push({ m, i, b }); });
+  }
+  const candidates = results.slice(0, Math.max(0, results.length - keep)).filter(({ b }) => {
+    const text = typeof b.content === 'string' ? b.content : '';
+    return text.length >= TRIM_MIN_CHARS && !text.startsWith(CLEARED);
+  });
+  const freed = Math.ceil(candidates.reduce((n, { b }) => n + blockChars(b), 0) / 4);
+  if (freed < atLeast) return 0;
+  for (const { m, i, b } of candidates) {
+    const chars = blockChars(b);
+    const name = names.get(b.tool_use_id) || 'this tool';
+    m.content[i] = { ...b, content: `${CLEARED}: ${name} returned ${chars.toLocaleString()} characters here, removed to keep the conversation small. Run it again if you need it.]` };
+  }
+  return freed;
+}
+
 export const IMAGE_BUDGET = 6_000_000;
 export function withinImageBudget(messages, budget = IMAGE_BUDGET) {
   let used = 0;
@@ -273,14 +339,16 @@ async function streamTurn({ client, messages, model, system, tools, onText, onTo
   // — no message_stop, no stop reason — was cut, and used to be taken as a complete,
   // silent answer: the "it stops midway for no reason" bug.
   let sawStop = false;
-  const usage = { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 };
+  // `credits` is what the gateway counted against the plan for this request — real cost,
+  // the one unit the plan, the dashboard and this CLI all show.
+  const usage = { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0, cache_creation_input_tokens: 0, credits: 0 };
   // Usage can arrive at the START of a stream (Anthropic-format providers) or only at
   // the END, in message_delta (OpenAI-format providers, translated by the gateway —
   // their usage exists only once generation finishes). Reading input from message_start
   // alone recorded every OpenAI-format turn as 0 input tokens.
   const takeUsage = (u) => {
     if (!u) return;
-    for (const k of ['input_tokens', 'output_tokens', 'cache_read_input_tokens', 'cache_creation_input_tokens']) {
+    for (const k of ['input_tokens', 'output_tokens', 'cache_read_input_tokens', 'cache_creation_input_tokens', 'credits']) {
       if (u[k] != null && Number.isFinite(Number(u[k]))) usage[k] = Number(u[k]);
     }
   };
@@ -395,7 +463,7 @@ export async function runAgent({
   client, messages, model, cwd, permissions, signal, tui = null,
   extraSystem = '', maxIterations = MAX_ITERATIONS, silent = false,
   onText = null, onEvent = null, systemOverride = null, journal = null,
-  subagents = true, onContext = null,
+  subagents = true, onContext = null, trimContext = true,
 }) {
   // Loop detection. A call is identified by its tool, its input, and how many files had
   // been changed when it was made — so edit → test → edit → test is progress (the count
@@ -404,7 +472,7 @@ export async function runAgent({
   const repeats = new Map();
   // input = fresh input, cached = prompt-cache reads (billed far cheaper), and
   // context = the real size of the last prompt sent, as the provider counted it.
-  const totals = { input: 0, cached: 0, output: 0, tools: 0, context: 0 };
+  const totals = { input: 0, cached: 0, output: 0, tools: 0, context: 0, credits: 0 };
   // Read once per request, not per turn: an agent that rewrites JAITUS.md mid-task
   // should not change the rules it is being judged by halfway through.
   // The model is told when it is in plan mode — it used to find out only by having its
@@ -438,6 +506,12 @@ export async function runAgent({
   let continuing = false;
 
   for (let iteration = 0; iteration < maxIterations; iteration++) {
+    // Old tool outputs are cleared once the conversation is large (see TRIM_AT) — in
+    // place, so the saved session shrinks too and the cache stays warm afterwards.
+    if (trimContext) {
+      const freed = clearOldToolResults(messages);
+      if (freed && tui?.notice) tui.notice(`Cleared old tool output (~${Math.round(freed / 1000)}k tokens) to keep each request small.`, 'info');
+    }
     let streamed = false;
     const spin = tui ? { stop: () => {}, update: () => {} } : (silent ? { stop: () => {}, update: () => {} } : spinner(glyph('Working…', 'Working...')));
     if (tui) tui.setStatus(`${c.brand(glyph('•', '*'))} ${c.brand(glyph('Working…', 'Working...'))}`);
@@ -532,6 +606,7 @@ export async function runAgent({
     totals.input += turn.usage.input_tokens || 0;
     totals.cached += (turn.usage.cache_read_input_tokens || 0) + (turn.usage.cache_creation_input_tokens || 0);
     totals.output += turn.usage.output_tokens || 0;
+    totals.credits += Number(turn.usage.credits) || 0;
     const promptSize = (turn.usage.input_tokens || 0) + (turn.usage.cache_read_input_tokens || 0) + (turn.usage.cache_creation_input_tokens || 0);
     if (promptSize) {
       totals.context = promptSize + (turn.usage.output_tokens || 0);
@@ -708,7 +783,8 @@ export async function runAgent({
         const done = `  ${toolMark(call.name)} ${c.dim(String(label).slice(0, 100))} ${c.dim(`· ${took}s`)}`;
         if (row) {
           tui.clearStatus();
-          row.update({ status: 'ok', took, preview: previewFor(call.name, output) });
+          // The whole output travels with the row (capped), so a click can open it.
+          row.update({ status: 'ok', took, preview: previewFor(call.name, output), full: String(output ?? '').slice(0, 200_000) });
         } else if (tui) { tui.clearStatus(); tui.print(done, 'tool'); } else if (!silent) out(done);
         tui?.recordActivity?.({ id: activityId, name: call.name, label, status: 'ok', detail: String(output).slice(0, 2000) });
         onEvent?.({ type: 'tool_result', name: call.name, input: call.input, ok: true, output });
@@ -761,7 +837,7 @@ export async function runAgent({
         const bad = `  ${c.red(glyph('✗', 'x'))} ${c.dim(String(label).slice(0, 80))} ${c.dim(`· ${took}s`)} — ${msg.slice(0, 120)}`;
         if (row) {
           tui.clearStatus();
-          row.update({ status: 'failed', took, error: msg.split('\n')[0].slice(0, 200), preview: msg.includes('\n') ? msg : '' });
+          row.update({ status: 'failed', took, error: msg.split('\n')[0].slice(0, 200), preview: msg.includes('\n') ? msg : '', full: msg.slice(0, 200_000) });
         } else if (tui) { tui.clearStatus(); tui.print(bad, 'tool'); } else if (!silent) out(bad);
         tui?.recordActivity?.({ id: activityId, name: call.name, label, status: 'failed', detail: msg.slice(0, 2000) });
         onEvent?.({ type: 'tool_result', name: call.name, input: call.input, ok: false, error: msg });

package/src/agent/permissions.js

@@ -16,7 +16,7 @@
 
 import path from 'node:path';
 import { c, out, askKey, glyph } from '../ui.js';
-import { decide, ruleForCall, broaderRule, DEFAULT_DENY, subjectOf } from './rules.js';
+import { decide, ruleForCall, broaderRule, DEFAULT_DENY, subjectOf, wideAllows } from './rules.js';
 
 export class PermissionDenied extends Error {}
 
@@ -44,6 +44,8 @@ export function createPermissions({
   const api = {
     get mode() { return current; },
     get rules() { return { allow: [...savedAllow], deny: [...savedDeny], session: [...sessionAllow] }; },
+    /** Saved rules that take a whole tool out of the mode's hands (see wideAllows). */
+    get wide() { return wideAllows(savedAllow); },
 
     /** Add a rule. `persist` writes it to settings via onRulesChange. */
     addRule(rule, { persist = false, kind = 'allow' } = {}) {

package/src/agent/rules.js

@@ -206,15 +206,39 @@ export function ruleForCall(toolName, input, cwd) {
   return `${toolName}(${relative && !relative.startsWith('..') ? relative : subject})`;
 }
 
-/** A broader rule, offered beside the exact one: the whole directory, or the tool. */
+/**
+ * A broader rule, offered beside the exact one: the file's directory. Never the whole
+ * tool. "Always allow every run command" used to be the second option on every command
+ * prompt; one click on it saved a rule that approves every command in that folder in
+ * every mode, forever — after which Ask, Auto-edit and Bypass all behaved the same and
+ * nothing on screen said why. A tool-wide rule can still be written on purpose with
+ * `/permissions allow run_command`; it is just never one click away.
+ */
 export function broaderRule(toolName, input, cwd) {
   const subject = subjectOf(toolName, input);
   if (['write_file', 'edit_file', 'read_file', 'read_image', 'list_files'].includes(toolName) && subject) {
     const relative = cwd ? normalise(path.relative(cwd, path.resolve(cwd, subject))) : subject;
     const dir = relative.includes('/') ? relative.slice(0, relative.lastIndexOf('/')) : '';
-    return dir && !dir.startsWith('..') ? `${toolName}(${dir}/**)` : `${toolName}`;
+    if (dir && !dir.startsWith('..')) return `${toolName}(${dir}/**)`;
+  }
+  return ruleForCall(toolName, input, cwd);
+}
+
+/**
+ * Saved allow rules that approve a whole tool — `run_command`, `edit_file(**)` — for the
+ * tools a mode is about. While one exists, the mode no longer decides that tool, so the
+ * mode's label is only half the truth; callers say so beside it.
+ */
+export function wideAllows(allow = []) {
+  const GATED = ['run_command', 'background_run', 'write_file', 'edit_file'];
+  const out = [];
+  for (const rule of allow) {
+    const parsed = typeof rule === 'string' ? parseRule(rule) : rule;
+    if (!parsed || !GATED.includes(parsed.tool)) continue;
+    const p = parsed.pattern;
+    if (p === null || p === '' || p === '*' || p === '**' || p === '**/*') out.push(parsed.source);
   }
-  return `${toolName}`;
+  return out;
 }
 
 /**

package/src/agent/tools.js

@@ -26,6 +26,18 @@ const MAX_READ_LINES = 2_000;
 
 export class ToolError extends Error {}
 
+/**
+ * Keep the start AND the end. For a test run or a build the end is where the failures and
+ * the summary are; cutting from the front kept the noise and threw away the answer.
+ */
+function truncateMiddle(text, limit) {
+  const s = String(text ?? '');
+  if (s.length <= limit) return s;
+  const head = Math.floor(limit / 3);
+  const tail = limit - head;
+  return `${s.slice(0, head)}\n\n[… ${s.length - limit} characters cut from the middle …]\n\n${s.slice(-tail)}`;
+}
+
 function truncate(text, limit = MAX_OUTPUT) {
   const s = String(text ?? '');
   if (s.length <= limit) return s;
@@ -560,8 +572,10 @@ export const TOOLS = [
           // the joined text cut the exit code off the end of any long output, so the
           // model could not tell whether the command had worked.
           const parts = [];
-          const stdout = truncate(out.text().trim(), 40_000);
-          const stderr = truncate(err.text().trim(), 16_000);
+          // 30k in all (the common agent limit for shell output): every later request
+          // re-sends it until it is cleared.
+          const stdout = truncateMiddle(out.text().trim(), 22_000);
+          const stderr = truncateMiddle(err.text().trim(), 8_000);
           if (stdout) parts.push(stdout);
           if (stderr) parts.push(`stderr:\n${stderr}`);
           if (note) parts.push(note);
@@ -832,6 +846,29 @@ export const TOOLS = [
       return `Stopped ${input.id}.`;
     },
   },
+
+  {
+    // The model loads a skill's instructions itself when a task matches one. Only each
+    // skill's one-line description rides along with every request; the body (a few
+    // thousand tokens) is paid for only in conversations that need it.
+    name: 'load_skill',
+    description: 'Load the full instructions of a skill listed under "Skills" in the system prompt. Call it BEFORE starting a task that matches a skill\'s description, then follow what it says.',
+    needsPermission: false,
+    input_schema: {
+      type: 'object',
+      properties: { name: { type: 'string', description: 'The skill name, e.g. frontend-design.' } },
+      required: ['name'],
+    },
+    summarise: (i) => `skill ${i.name}`,
+    async run(input, { cwd }) {
+      const { discoverSkills } = await import('../skills.js');
+      const skills = discoverSkills(cwd || process.cwd());
+      const name = String(input.name || '').replace(/^\//, '').trim();
+      const skill = skills[name];
+      if (!skill) throw new ToolError(`No skill named ${name}. Available: ${Object.keys(skills).join(', ') || 'none'}.`);
+      return `Skill: ${skill.name}\n\n${skill.content}`;
+    },
+  },
 ];
 
 /** The live task list todo_write maintains; the session renders it in the panel. */

package/src/api.js

@@ -18,7 +18,9 @@ export function createClient() {
   const { baseUrl } = endpoints();
   if (!signedIn()) throw new NotSignedIn('Not signed in. Run `jaitus login` first.');
 
-  const base = { 'Content-Type': 'application/json', 'user-agent': 'jaitus-cli' };
+  // x-jaitus-features: what this build understands, so the gateway can use newer error
+  // codes (a used-up usage window) without an older CLI reading them as "went wrong".
+  const base = { 'Content-Type': 'application/json', 'user-agent': 'jaitus-cli', 'x-jaitus-features': 'usage-window' };
   const headers = (token) => ({ ...base, authorization: `Bearer ${token}` });
 
   return {

package/src/errors.js

@@ -18,7 +18,8 @@ const CATALOG = {
   rate_limited: { title: 'Slow down', hint: 'Wait a moment, then retry.' },
   context_too_long: { title: 'Conversation too long', hint: 'Run /compact, or start a new session.' },
   request_too_large: { title: 'Request too large', hint: 'Usually images: remove some, or run /compact to drop old ones. Images over 3.5 MB are shrunk automatically.' },
-  daily_limit_reached: { title: 'Daily limit reached', hint: 'Your plan\'s daily allowance resets tomorrow. /usage shows where you are.' },
+  daily_limit_reached: { title: 'Usage limit reached', hint: 'It refills automatically. /usage shows where you are.' },
+  window_limit_reached: { title: 'This usage window is used up', hint: 'It refills when the window ends — the rest of your month is still there. /usage shows when.' },
   token_expired: { title: 'Signed out', hint: 'Type /login to sign in again (or run `jaitus login`).' },
   refresh_race: { title: 'Sign-in was being renewed', hint: 'Try again.' },
   content_blocked: { title: 'Request refused', hint: 'Rephrase the request and try again.' },