@hncode/hncode 0.5.1 → 0.5.2

package/src/team/team.js

@@ -0,0 +1,311 @@
+// Creating, joining and leaving a team.
+//
+// A team is a roster on disk plus a task list. Nothing here runs an agent — that is the runner's
+// job, and keeping the two apart means the bookkeeping can be reasoned about (and tested)
+// without spawning anything.
+import fs from 'node:fs';
+import {
+  readTeamFile, writeTeamFile, deleteTeam, removeMember, updateMember,
+  formatAgentId, sanitizeName, teamDir, listTeams, inboxPath,
+} from './store.js';
+import { clearMailbox, writeToMailbox, readMailbox, readUnread, markAllRead } from './mailbox.js';
+import { pickColor } from './context.js';
+import { TEAM_LEAD_NAME, MAX_TEAMMATES } from './constants.js';
+
+/**
+ * Create a team with `leadName` as its lead.
+ *
+ * A name already in use is REFUSED rather than silently replaced: the existing roster and task
+ * history belong to a session that may still be running, and overwriting it would strand those
+ * members with no lead.
+ */
+export function createTeam({ teamName, description = '', leadName = TEAM_LEAD_NAME, leadSessionId, cwd }) {
+  const name = String(teamName || '').trim();
+  if (!name) return { ok: false, error: 'a team name is required' };
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9 _-]*$/.test(name)) {
+    return { ok: false, error: `"${name}" is not usable as a team name — letters, digits, spaces, - and _ only` };
+  }
+
+  const existing = readTeamFile(name);
+  if (existing) {
+    return { ok: false, error: `team "${name}" already exists (${existing.members.length} member(s)). Pick another name, or delete it first.` };
+  }
+
+  // NO members yet. The first one added becomes the lead — see addMember — so a team is not
+  // born with a placeholder on it, and "the first team member" is not quietly the second.
+  const team = {
+    name,
+    description: String(description || ''),
+    createdAt: Date.now(),
+    // Filled in when the first member joins. Until then the team has no leader, which is a
+    // true statement about it rather than a placeholder.
+    leadAgentId: '',
+    leadName,
+    leadSessionId: leadSessionId || '',
+    members: [],
+  };
+  writeTeamFile(name, team);
+  return { ok: true, team };
+}
+
+/**
+ * Put a member on the roster.
+ *
+ * Returns the member record. Re-adding an existing name updates it instead of duplicating —
+ * which is what re-spawning a teammate that died should do, and a duplicate would make every
+ * name-addressed message ambiguous.
+ */
+export function addMember(teamName, { name, agentType = 'general', model = '', taskId = null, cwd, prompt = '' }) {
+  const team = readTeamFile(teamName);
+  if (!team) return { ok: false, error: `no team "${teamName}"` };
+
+  const memberName = String(name || '').trim();
+  if (!memberName) return { ok: false, error: 'a teammate name is required' };
+  const teamLead = (readTeamFile(teamName) || {}).leadName || TEAM_LEAD_NAME;
+  if (memberName === teamLead) return { ok: false, error: `"${teamLead}" is the lead of this team` };
+
+  const others = team.members.filter((m) => m.name !== memberName);
+  if (others.length >= MAX_TEAMMATES) {
+    return { ok: false, error: `team "${teamName}" already has ${others.length} members (max ${MAX_TEAMMATES})` };
+  }
+
+  // THE FIRST MEMBER IS THE LEAD.
+  //
+  // A team with no leader is not a team — nothing can be reported TO — so the first member takes
+  // the role, and the team records its name and id. Every later member is a peer.
+  const isFirst = team.members.length === 0;
+
+  const color = pickColor(memberName, others.map((m) => m.color));
+  const member = {
+    agentId: formatAgentId(memberName, teamName),
+    name: memberName,
+    agentType,
+    // RANK, not trade. `agentType` says what a member does; this says where it sits. Kept as a
+    // field rather than derived from the name, so a lead can be renamed and a team can name its
+    // own leader.
+    role: isFirst ? 'lead' : 'member',
+    model,
+    color,
+    joinedAt: Date.now(),
+    cwd: cwd || process.cwd(),
+    taskId,
+    prompt,
+    isActive: true,
+    // What the member is DOING. `isActive` alone could not say it: a round spends most of its
+    // time blocked on the model, and a member that has never run is not working either.
+    phase: 'starting',
+  };
+  if (isFirst) {
+    team.leadName = memberName;
+    team.leadAgentId = member.agentId;
+  }
+  team.members = [...others, member];
+  writeTeamFile(teamName, team);
+  return { ok: true, member };
+}
+
+/** Mark a member idle or active. Used by the roster view and by the lead's status line. */
+/**
+ * Record what a member is doing.
+ *
+ * `phase` is the real answer and `isActive` is derived from it, so a caller that only knows
+ * one thing still gets a truthful roster.
+ */
+export function setMemberActive(teamName, memberName, isActive, phase) {
+  const p = phase || (isActive === false ? 'idle' : 'starting');
+  return updateMember(teamName, memberName, { isActive, phase: p });
+}
+
+/**
+ * Take a member off the roster.
+ *
+ * Their inbox goes with them: it is addressed by name, so leaving the file behind means the next
+ * member to take that name inherits a stranger's mail.
+ */
+export function removeTeammate(teamName, memberName) {
+  const lead = (readTeamFile(teamName) || {}).leadName || TEAM_LEAD_NAME;
+  if (memberName === lead) return { ok: false, error: 'the lead cannot be removed' };
+  const team = readTeamFile(teamName);
+  if (!team) return { ok: false, error: `no team "${teamName}"` };
+  if (!team.members.some((m) => m.name === memberName)) {
+    return { ok: false, error: `"${memberName}" is not on team "${teamName}"` };
+  }
+  removeMember(teamName, memberName);
+  clearMailbox(teamName, memberName);
+  return { ok: true };
+}
+
+/**
+ * Dissolve a team.
+ *
+ * Members are told first, so a running teammate learns why its team vanished rather than finding
+ * an empty roster on its next poll.
+ */
+export function disbandTeam(teamName, { reason = 'the lead ended the team' } = {}) {
+  const team = readTeamFile(teamName);
+  if (!team) return { ok: false, error: `no team "${teamName}"` };
+  // By ROLE: a team whose leader is named something else still has exactly one.
+  const members = team.members.filter((m) => m.role !== 'lead');
+  for (const m of members) {
+    try {
+      writeToMailbox(teamName, m.name, {
+        from: TEAM_LEAD_NAME,
+        text: `[team ending] ${reason}`,
+        summary: 'team ending',
+      });
+    } catch { /* the directory is about to go anyway */ }
+  }
+  deleteTeam(teamName);
+  return { ok: true, told: members.length };
+}
+
+/** The roster entry for a name, or null. */
+export function findMember(teamName, name) {
+  const team = readTeamFile(teamName);
+  if (!team) return null;
+  return team.members.find((m) => m.name === name) || null;
+}
+
+/** Everyone except `except`, used for broadcast. */
+export function otherMembers(teamName, except) {
+  const team = readTeamFile(teamName);
+  if (!team) return [];
+  return team.members.filter((m) => m.name !== except);
+}
+
+/**
+ * The roster as a model should read it.
+ *
+ * One line per member with the state that affects what the reader should do: who is idle (can be
+ * given work), who is busy (do not interrupt), what each owns.
+ */
+/**
+ * The roster as a user or a model should read it, by NAME.
+ *
+ * `formatRoster` takes the team object; a caller usually holds only the name, and reading the
+ * file is what the rest of this module does anyway.
+ */
+/**
+ * The member list, by name. Empty when there is no such team.
+ *
+ * `readTeamFile` is store.js; this is the accessor the rest of the program should use, so a
+ * caller never has to know which module owns the file.
+ */
+export function rosterOf(teamName) {
+  const team = readTeamFile(teamName);
+  return (team && Array.isArray(team.members)) ? team.members : [];
+}
+
+/**
+ * The name of the member who leads this team.
+ *
+ * Falls back to the default name for a team written before `leadName` existed — nothing
+ * about such a team can be improved by guessing a different leader.
+ */
+export function leadOf(teamName) {
+  const team = readTeamFile(teamName);
+  if (!team) return TEAM_LEAD_NAME;
+  if (team.leadName) return team.leadName;
+  const byRole = (team.members || []).find((m) => m.role === 'lead');
+  return (byRole && byRole.name) || TEAM_LEAD_NAME;
+}
+
+/**
+ * Mail for the team's lead that it has not read yet.
+ *
+ * "THE LEAD" IS A ROSTER ROLE HELD BY A REAL AGENT. `addMember` gives the `lead` role to the
+ * FIRST member added, and that member has a full agent identity like anyone else — `agentId`,
+ * `agentType`, `cwd`, a phase, its own inbox. The user is never on the roster, so a message
+ * addressed to the lead is addressed to an agent, and sending the lead an instruction is the
+ * normal way to command the team.
+ *
+ * `TEAM_LEAD_NAME` is a separate thing: the fixed alias the USER'S OWN sends carry (`/team msg`,
+ * the panel composer) and that harness notices use as their `from` (`disbandTeam`). A teammate
+ * cannot be named it — `addMember` refuses — so mail under that alias is always the user's own
+ * words, which is why the reader skips it. Both names are otherwise collected, because a member
+ * may be addressed under the lead's roster name or the alias.
+ */
+export function readLeadInbox(teamName) {
+  const team = readTeamFile(teamName);
+  if (!team) return [];
+  const leadNames = new Set([leadOf(teamName), TEAM_LEAD_NAME]);
+  const out = [];
+  for (const n of leadNames) {
+    for (const m of readUnread(teamName, n)) {
+      // Skip the USER'S OWN sends. Every message the user writes from the panel or `/team msg` is
+      // stamped `from: TEAM_LEAD_NAME`, so it must not come back as mail from the team: typing
+      // "你好" to the lead and being handed `team-lead: 你好` as unread team traffic is the model
+      // reading the person's own instruction as though an agent had sent it.
+      //
+      // The test is the SENDER being the alias — NOT the lead being the user. The lead is a
+      // rostered agent; a message FROM it is real mail and is kept.
+      if (m.from === TEAM_LEAD_NAME) continue;
+      out.push({ ...m, _to: n });
+    }
+  }
+  return out.sort((a, b) => String(a.timestamp || '').localeCompare(String(b.timestamp || '')));
+}
+
+/** Mark the messages `readLeadInbox` returned as read. */
+export function markLeadInboxRead(teamName, messages) {
+  const byName = new Map();
+  for (const m of messages || []) {
+    const to = m._to || leadOf(teamName);
+    if (!byName.has(to)) byName.set(to, []);
+    byName.get(to).push(m);
+  }
+  let n = 0;
+  for (const [to, batch] of byName) n += markAllRead(teamName, to, batch);
+  return n;
+}
+
+
+/**
+ * The lead's unread mail as one block of text, or '' when there is none.
+ *
+ * `mark` decides whether reading it counts as seeing it. The caller that FEEDS it to the model
+ * passes true — the model has now seen it — while a reader that only counts messages passes
+ * false, or the count would empty the box before anyone read it.
+ */
+export function formatLeadInbox(teamName, { mark = false } = {}) {
+  const unread = readLeadInbox(teamName);
+  if (!unread.length) return '';
+  if (mark) markLeadInboxRead(teamName, unread);
+  const body = unread.map((m) => `${m.from}: ${String(m.text || '').trim()}`).join('\n');
+  return `${unread.length} unread message(s) for the team lead. Answer with the SendMessage tool.\n\n${body}`;
+}
+
+export function readRoster(teamName) {
+  return formatRoster(readTeamFile(teamName));
+}
+
+export function formatRoster(team) {
+  if (!team) return 'No team.';
+  const lines = [`Team "${team.name}"${team.description ? ` — ${team.description}` : ''}`];
+  for (const m of team.members) {
+    const isLead = m.role === 'lead';
+    // `phase` when it is there; `isActive` for a member written by an older build.
+    const phase = m.phase || (m.isActive === false ? 'idle' : 'starting');
+    const state = isLead ? 'lead' : phase;
+    // Unread mail from SOMEONE ELSE. The lead's count is reported rather than hidden — a
+    // teammate waiting for an answer is what the roster should show — but the user's own sends
+    // are excluded, or `readRoster` reports a message the user just typed as mail they received.
+    const unread = readUnread(team.name, m.name).filter((x) => x.from !== TEAM_LEAD_NAME).length;
+    const bits = [state];
+    if (m.taskId) bits.push(`task ${m.taskId}`);
+    if (unread) bits.push(`${unread} unread`);
+    lines.push(`  ${m.name.padEnd(16)} ${bits.join(', ')}`);
+  }
+  return lines.join('\n');
+}
+
+/** Teams that exist on disk, for /team with no argument. */
+export function knownTeams() {
+  return listTeams().map((t) => ({
+    name: t.name,
+    description: t.description,
+    members: t.members.length,
+    createdAt: t.createdAt,
+    leadSessionId: t.leadSessionId,
+  }));
+}

package/src/team-panel.js

@@ -0,0 +1,226 @@
+// The team panel: who is on the team, what each is doing, and a composer to message them.
+//
+// WHY A PANEL AND NOT ONLY THE COMMAND
+// ------------------------------------
+// `/team msg alice ...` works, but a team is a thing you WATCH. The question a user has is "is
+// anyone stuck, and who do I need to nudge" — and answering it from the command line means running
+// `/team list`, reading four lines, and remembering them. The panel keeps the roster and each
+// member's recent traffic on screen while you type.
+//
+// SHAPE
+// -----
+// Left: the roster, one line per member — name, live state, unread count. Below it a one-line
+// composer. Enter sends to the selected member; Tab moves between members; Esc leaves.
+//
+// It follows tasks-browser.js: a pure renderer plus a key handler, so both are testable without a
+// terminal.
+import fs from 'node:fs';
+import { C } from './colors.js';
+import { visualWidth, fit } from './term.js';
+import { readTeamFile } from './team/store.js';
+import { readMailbox, writeToMailbox } from './team/mailbox.js';
+import { readTasks, formatTasks } from './team/tasks.js';
+import { TEAM_LEAD_NAME } from './team/constants.js';
+
+
+/** The state a panel needs, created once when it opens. */
+export function makeTeamPanel(teamName) {
+  return {
+    teamName,
+    selectedIndex: 0,
+    /** 'roster' or 'compose', so a keystroke means one thing at a time. */
+    mode: 'roster',
+    composing: '',
+    caret: 0,
+    flash: '',
+    /** How much of each member's recent mail to show. */
+    mailLines: 4,
+  };
+}
+
+/**
+ * The members as rows, in roster order.
+ *
+ * The LEAD is included and is selectable: the user is the boss, and talking to the lead is how
+ * they give the team its work.
+ */
+export function teamRows(panel) {
+  const team = readTeamFile(panel.teamName);
+  if (!team || !Array.isArray(team.members)) return [];
+  return team.members.map((m) => {
+    // Unread mail TO this member from someone ELSE. The user's own sends are stamped
+    // `from: TEAM_LEAD_NAME` and sit in the recipient's box until it reads them, so counting
+    // them made the roster show `1 new` for a message the user had just typed themselves —
+    // a badge nothing could ever clear and nothing ever delivered.
+    const unread = readMailbox(panel.teamName, m.name)
+      .filter((x) => !x.read && x.from !== TEAM_LEAD_NAME).length;
+    return {
+      name: m.name,
+      model: m.model || '',
+      color: m.color || '',
+      // By ROLE: a team that names its own leader still shows it as the lead.
+      isLead: m.role === 'lead',
+      unread,
+      // The member's own PHASE — what it is doing, not whether a flag is set. `starting` covers
+      // one written before the phase existed; `working` means a tool is actually running, and
+      // `thinking` means it is blocked on the model, which is most of a round.
+      //
+      // `lead` is decided by ROLE, not by the name matching the wire alias. The alias test never
+      // matched a real lead (`addMember` gives the role to the first member added, whose name is
+      // its own — `NiceHello_01`, not `team-lead`), so the branch was dead and every lead fell
+      // through to its phase.
+      state: (m.role === 'lead') ? 'lead'
+        : (m.phase || (m.isActive === false ? 'idle' : 'starting')),
+    };
+  });
+}
+
+/** The traffic for one member: what they said, and what was said to them, newest last. */
+export function memberTraffic(teamName, name, limit = 4) {
+  const box = readMailbox(teamName, name);
+  return box.slice(-limit).map((m) => ({
+    from: m.from,
+    text: String(m.text || '').split('\n')[0].slice(0, 100),
+    at: m.timestamp,
+  }));
+}
+
+/** Draw the panel. Exactly `rows` lines, each `cols` wide. */
+export function renderTeamPanel(panel, cols, rows) {
+  const out = [];
+  const push = (s) => { out.push(fit(s, cols)); };
+
+  const team = readTeamFile(panel.teamName);
+  const memberCount = (team && team.members) ? team.members.length : 0;
+  const title = team
+    ? ` Team "${panel.teamName}" — ${memberCount} member(s)`
+    : ` Team "${panel.teamName}" — the roster is gone`;
+
+  push(C.border + '─'.repeat(cols) + C.reset);
+  push(C.cyan + C.bold + title + C.reset
+    + (panel.flash ? `   ${C.yellow}${panel.flash}${C.reset}` : ''));
+
+  const roster = teamRows(panel);
+  if (!roster.length) {
+    push('  ' + C.gray + 'No members. Add one with /team add <name>.' + C.reset);
+  }
+
+  // The roster, then the selected member's traffic, then the composer.
+  const composerRows = 3;
+  const trafficRoom = Math.max(0, Math.min(panel.mailLines + 2, rows - roster.length - composerRows - 6));
+
+  for (let i = 0; i < roster.length && out.length < rows - composerRows - trafficRoom - 2; i++) {
+    const m = roster[i];
+    const sel = i === panel.selectedIndex;
+    const ptr = sel ? `${C.cyan}❯${C.reset} ` : '  ';
+    const name = (m.isLead ? `${m.name} (lead)` : m.name).padEnd(20);
+    // The states a member can be in, each with its own colour: green is a tool actually running,
+    // cyan is blocked on the model, grey is waiting for work, yellow is an agent that has not
+    // begun. `starting` used to fall through to `not started`, so a lead mid-launch claimed the
+    // one thing that was certainly false about it — this is the row the user read as "my lead
+    // never came up", and the correct reading was "it is on its way".
+    const state = m.state === 'lead' ? `${C.gray}lead${C.reset}`
+      : m.state === 'working' ? `${C.green}working${C.reset}`
+        : m.state === 'thinking' ? `${C.cyan}thinking${C.reset}`
+          : m.state === 'idle' ? `${C.gray}idle${C.reset}`
+            : m.state === 'starting' ? `${C.yellow}starting${C.reset}`
+              : `${C.yellow}not started${C.reset}`;
+    const mail = m.unread ? `${C.yellow} ${m.unread} new${C.reset}` : '';
+    const model = m.model ? `${C.gray} ${m.model}${C.reset}` : '';
+    push(sel
+      ? `${ptr}${C.cyan}${name}${C.reset}${state}${mail}${model}`
+      : `${ptr}${name}${state}${mail}${model}`);
+  }
+
+  // What the selected member has been saying.
+  const sel = roster[panel.selectedIndex];
+  if (sel && trafficRoom > 0) {
+    push('');
+    push(`  ${C.gray}── ${sel.name} ──${C.reset}`);
+    const traffic = memberTraffic(panel.teamName, sel.name, trafficRoom);
+    if (!traffic.length) push('  ' + C.gray + '(no messages yet)' + C.reset);
+    for (const t of traffic) {
+      // `team-lead` is the alias the USER'S own sends carry, so this line reads "you wrote this".
+      // It is NOT a statement that the lead is the user — the lead is a rostered agent under its
+      // own name. That misreading once removed this very alias check from the inbox reader, which
+      // made a message you sent to your lead come back to you as though an agent had sent it.
+      const who = t.from === TEAM_LEAD_NAME ? 'you' : t.from;
+      push(`  ${C.gray}${who}:${C.reset} ${t.text}`);
+    }
+  }
+
+  // The shared task list, one line, so "is the team moving" needs no second screen.
+  const tasks = readTasks(panel.teamName);
+  if (tasks.length && out.length < rows - composerRows - 1) {
+    const open = tasks.filter((t) => t.status !== 'completed' && t.status !== 'cancelled').length;
+    push('  ' + C.gray + `${tasks.length - open}/${tasks.length} tasks done${C.reset}`);
+  }
+
+  while (out.length < rows - composerRows) out.push(' '.repeat(cols));
+
+  // The composer. One line, always visible, and it SAYS who it will go to — the failure mode of a
+  // chat box is sending to the wrong person and only finding out afterwards.
+  push(C.border + '─'.repeat(cols) + C.reset);
+  if (panel.mode === 'compose') {
+    push(`  ${C.cyan}→ ${sel ? sel.name : '?'}${C.reset} ${panel.composing}${C.cyan}█${C.reset}`);
+    push('  ' + C.gray + 'Enter send · Esc cancel' + C.reset);
+  } else {
+    push('  ' + C.gray + 'Enter write · Tab next · ↑↓ select · Esc close' + C.reset);
+    push('');
+  }
+
+  return out.slice(0, rows);
+}
+
+/**
+ * Keys for the panel.
+ *
+ * Returns an action for the caller to perform, rather than performing it: the panel does not own
+ * the frame, the agent or the clipboard, and a renderer that acts is a renderer that cannot be
+ * tested.
+ */
+export function handleTeamPanelKey(panel, t) {
+  if (!t) return { handled: false };
+
+  if (panel.mode === 'compose') {
+    if (t.key === 'escape') { panel.mode = 'roster'; panel.composing = ''; panel.caret = 0; return { handled: true }; }
+    if (t.key === 'enter') {
+      const text = panel.composing.trim();
+      const roster = teamRows(panel);
+      const to = roster[panel.selectedIndex];
+      panel.composing = '';
+      panel.caret = 0;
+      panel.mode = 'roster';
+      if (!text || !to) return { handled: true };
+      return { handled: true, action: 'send', to: to.name, text };
+    }
+    if (t.key === 'backspace') {
+      panel.composing = panel.composing.slice(0, -1);
+      panel.caret = panel.composing.length;
+      return { handled: true };
+    }
+    if (t.ch && !t.key?.startsWith('c-')) { panel.composing += t.ch; panel.caret = panel.composing.length; return { handled: true }; }
+    return { handled: true };
+  }
+
+  const roster = teamRows(panel);
+  const n = roster.length;
+
+  if (t.key === 'escape' || t.ch === 'q') return { handled: true, action: 'close' };
+  if (t.key === 'enter') { if (n) { panel.mode = 'compose'; panel.composing = ''; } return { handled: true }; }
+  if (t.key === 'tab' || t.key === 'down') { if (n) panel.selectedIndex = (panel.selectedIndex + 1) % n; return { handled: true }; }
+  if (t.key === 's-tab' || t.key === 'up') { if (n) panel.selectedIndex = (panel.selectedIndex - 1 + n) % n; return { handled: true }; }
+  if (t.key === 'home') { panel.selectedIndex = 0; return { handled: true }; }
+  if (t.key === 'end') { if (n) panel.selectedIndex = n - 1; return { handled: true }; }
+  // `r` marks everything read for the selected member — the way to clear a "3 new" badge you have
+  // already looked at in the traffic pane.
+  if (t.ch === 'r' && n) return { handled: true, action: 'markRead', name: roster[panel.selectedIndex].name };
+  return { handled: false };
+}
+
+/** Deliver a message from the panel. Separated so the key handler stays pure. */
+export function sendFromPanel(teamName, to, text) {
+  if (!to || !text) return false;
+  writeToMailbox(teamName, to, { from: TEAM_LEAD_NAME, text: String(text) });
+  return true;
+}

package/src/term.js

@@ -379,11 +379,38 @@ const tokCache = new Map();
 const TOK_CACHE_MAX = 20000;
 const TOK_CACHE_MAX_LEN = 4096;   // only memoise strings this short
 
+/**
+ * The same estimate, UNROUNDED — for summing many small chunks.
+ *
+ * `estimateTokens` rounds up, which is right for measuring one finished body: a 5-character
+ * message should not read as 1.25 tokens.
+ *
+ * It is wrong for a STREAM. Deltas arrive a few characters at a time, and each one took
+ * `ceil(ascii / 4)` — `ceil(3/4)` is 1, so three characters were billed as a whole token. Over
+ * hundreds of chunks that inflated the running figure badly: measured at +33% on ordinary
+ * English, and the visible symptom was the output counter DROPPING (3000 -> 2300) the moment the
+ * provider's exact `usage` arrived and replaced the estimate. Nothing was lost; the estimate had
+ * been lying.
+ *
+ * So the running counter accumulates this unrounded value, and rounds once when it displays.
+ * Callers that measure a complete string keep using `estimateTokens`.
+ */
+export function estimateTokensFloat(text) {
+  const s = String(text ?? '');
+  let ascii = 0, nonAscii = 0;
+  for (const ch of s) {
+    if (ch.codePointAt(0) <= 127) ascii++;
+    else nonAscii++;
+  }
+  return ascii / 4 + nonAscii;
+}
+
 export function estimateTokens(text) {
   const s = String(text ?? '');
   if (s.length <= TOK_CACHE_MAX_LEN) {
     const hit = tokCache.get(s);
     if (hit !== undefined) return hit;
+    if (hit !== undefined) return hit;
     let ascii = 0, nonAscii = 0;
     for (const ch of s) {
       if (ch.codePointAt(0) <= 127) ascii++;

package/src/tool-result.js

@@ -192,22 +192,37 @@ export function planTrim(messages, keepRatio, mustKeep) {
   // A budget of 0 means "elide everything eligible"; a budget of 1 means "keep it
   // all", in which case we still elide the already-marked ones so a repeated call
   // is a no-op rather than a growing patch.
-  const budget = totalBytes * ratio;
+  // The share of the ELIGIBLE text to keep, not of `totalBytes`. `totalBytes` counts the
+  // pointers left by earlier passes, so after a few passes it mostly describes text that can no
+  // longer be elided — and a budget drawn from it stops constraining the loop.
+  const eligibleBytes = candidates.reduce((n, i) => n + messages[i].content.length, 0);
+  const budget = eligibleBytes * ratio;
   const keep = new Set();
   let keepBytes = 0;
   for (let k = candidates.length - 1; k >= 0; k--) {
     const i = candidates[k];
     if (i === mustKeep) { keep.add(i); keepBytes += messages[i].content.length; continue; }
     const size = messages[i].content.length;
-    // Keep this chunk if we are still under budget, but ALWAYS keep the single
-    // newest result: a trim that elides the output the model is currently reading
-    // is how a working turn turns into a confused one.
-    if (keepBytes + size <= budget || keep.size === 0) {
+    // Under budget: keep. Otherwise elide — except for the result the model is reading right
+    // now, which the `mustKeep` branch above has already kept.
+    //
+    // There used to be a `|| keep.size === 0` here, meaning "always keep at least the newest".
+    // `mustKeep` is what actually protects the live result, and the override made a single large
+    // result impossible to trim: it was the only candidate, so it was always "the newest", so
+    // the budget never applied and the trim elided nothing.
+    if (keepBytes + size <= budget) {
       keep.add(i);
       keepBytes += size;
     }
   }
 
+  // THE FLOOR: never elide everything.
+  //
+  // The budget can be smaller than every candidate — one 200k result against a 60k budget is the
+  // ordinary case, because a long turn leaves the history with only the newest result still
+  // un-elided. Without this the trim would replace that result with a pointer, which is worse
+  // than not trimming: the model loses the output it just asked for.
+  if (!keep.size && candidates.length) keep.add(candidates[candidates.length - 1]);
   const elide = [];
   let elideBytes = 0;
   for (const i of candidates) {