@hncode/hncode 0.6.2 → 0.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hncode/hncode",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "hncode — A cyan-blue TUI AI coding agent with zero runtime dependencies.",
   "type": "module",
   "main": "src/index.js",

package/src/agent.js

@@ -73,10 +73,13 @@ const COMPACTION_INSTRUCTION = [
   '',
   'Be concise and proportional: a long multi-step task warrants detail, a nearly finished exchange needs only a sentence or two.',
   '',
-  'Respond with text only. Do not call any tools. Any tool-call syntax in your answer is discarded and scores the handoff as failed.'
+  'Respond with text only. Do not call any tools. Any tool-call syntax in your answer is discarded and scores the handoff as failed.',
+  '',
+  'That includes XML-style tool syntax such as `<||DSML||invoke name="...">` or `<function_call>`: no such tag is',
+  'recognised here, so it becomes part of the summary and the next turn reads it as a step that happened.',
 ].join('\n');
-
 // Trailing note: the model should RESUME, not answer the summary.
+
 // A summariser can answer with tool-call syntax even when no tools were offered — the format is in its
 // training data, and a model interrupted mid-workflow reaches for it. Nothing was called, so the text is
 // noise, and left in a handoff summary the next turn reads it as a step that happened.
@@ -96,10 +99,20 @@ function stripToolCallText(text) {
   let out = text;
   // A special-token block: closed form, or an unterminated one running to the end of its line.
   out = out.replace(/<\|tool_call\|>[^\n]*(?:<\|\/tool_call\|>)?/g, '');
-  // Fenced block form.
+  // A fenced block form.
   out = out.replace(/```tool_call[\s\S]*?```/g, '');
   // A bare JSON object on its own lines that declares a tool invocation.
   out = out.replace(/^\s*\{[^\n]*"name"\s*:\s*"[^"]+"[^\n]*"arguments"[^\n]*\}\s*$/gm, '');
+  // THE DSML DIALECT. Some models write a tool call as an XML-ish block with a doubled delimiter around the
+  // tag name (`<||DSML||invoke name="…">`), which none of the patterns above match. It arrives as a whole
+  // block, so it is removed as one — an unterminated block included, since a summariser cut off by the token
+  // limit leaves exactly that.
+  out = out.replace(/<\|+\|?DSML\|?\|+[\s\S]*?(?=<\/\|\|+DSML\|\|+>|$)/gi, '');
+  out = out.replace(/<\/?\|+\|?DSML\|?\|+[^>]*>/gi, '');
+  // THE `<function_call>` DIALECT and its `<tool_call>` sibling: a JSON payload wrapped in a tag. Removed with
+  // its body when both tags are present, and on its own when the body follows on the next line.
+  out = out.replace(/<(function_call|tool_call)>[\s\S]*?<\/\1>/gi, '');
+  out = out.replace(/<(function_call|tool_call)>[^\n]*/gi, '');
   out = out.replace(/\n{3,}/g, '\n\n').trim();
 
   if (out.length > 0) return out;
@@ -115,7 +128,6 @@ function stripToolCallText(text) {
 
 const COMPACTION_CONTINUATION_TEXT = 'Context compaction is complete — continue the work that was in progress when it began.';
 
-// Clip to a TOKEN budget, counting non-ASCII as one token per character (the same
 // Clip to a TOKEN budget, counting non-ASCII as one token per character (the same
 // rule estimateTokens uses). Slicing by characters is wrong for CJK text: 4000
 // Chinese characters are ~4000 tokens, not ~1000.
@@ -708,6 +720,16 @@ const filtered = (Array.isArray(cfg.toolFilter) && cfg.toolFilter.length
           // What it IS used for: cost and `/usage`, where it is the only honest source, and the turn's
           // output counter.
           this.usage = addUsage(this.usage, e.usage);
+          // THE REAL SIZE OF THE REQUEST THAT JUST WENT OUT.
+          //
+          // `usage.input` is what the endpoint actually billed for this request, which is the honest answer
+          // to "how full is the context". The compaction threshold reads it (see `usedNow` below) instead of
+          // the local estimate, which runs low because it cannot model the provider's framing. `input`
+          // INCLUDES the reply's own prompt but not the reply, which is exactly the figure to compare against
+          // the limit.
+          if (e.usage && Number.isFinite(e.usage.input) && e.usage.input > 0) {
+            this.ctxReportedTokens = e.usage.input;
+          }
           this.onEvent({ type: 'usage', usage: e.usage, total: this.usage });
           break;
         case 'tool_start':
@@ -778,7 +800,16 @@ const filtered = (Array.isArray(cfg.toolFilter) && cfg.toolFilter.length
       // request that leaves less than the reserved headroom is compacted even
       // below 85%, so the reply has room to be generated.
       const maxCtx = this.cfg.maxContextTokens || 512000;
+      // THE PROVIDER'S OWN COUNT WINS WHEN THERE IS ONE.
+      //
+      // `usedTokens()` is a local estimate from the token ledger. The endpoint reports the real size with
+      // every reply, and that figure is what the status bar shows — but this decision used the estimate
+      // regardless, so a session the gauge put at 88% could stay under an 85% trigger indefinitely: the
+      // estimate runs low because it cannot model the provider's own message framing and tool preamble.
+      // Two numbers for the same thing is the bug; the reported one is the one that is true.
       let usedNow = this.usedTokens();
+      const reported = Number(this.ctxReportedTokens);
+      if (Number.isFinite(reported) && reported > 0) usedNow = reported;
       // THE MESSAGE THAT TRIGGERED THIS TURN IS NOT YET IN A REQUEST.
       //
       // The user's message is appended before `run()` is entered, so a fresh turn that pushes the

package/src/config.js

@@ -339,16 +339,16 @@ const b = baseUrl.replace(/\/+$/, '');
   // An empty base URL produces a relative endpoint like "/chat/completions",
   // which fetch() rejects with a URL-scheme error the model can't decode. Leave
   // the endpoint empty instead so the caller can show "not set".
-  // ANTHROPIC ALWAYS SPEAKS /v1/messages. A base of `https://api.anthropic.com` (which is what the
-  // provider table stores, and what people type) produced `…/messages` and 404'd; adding /v1 only when
-  // the base does not already carry a version segment makes both spellings work.
-  //
-  // The trailing slashes are stripped above, which is what kept `https://api.anthropic.com/v1/` from
-  // becoming `…/v1//messages`.
-  const versioned = protocol === 'anthropic' && !/\/v\d+$/.test(b) ? `${b}/v1` : b;
-  const endpoint = !b ? '' : (protocol === 'anthropic' ? `${versioned}/messages`
-    : protocol === 'responses' ? `${b}/responses`
-    : `${b}/chat/completions`);
+  // ANTHROPIC ALWAYS SPEAKS /v1/messages. A base of `https://api.anthropic.com` (which is what the
+  // provider table stores, and what people type) produced `…/messages` and 404'd; adding /v1 only when
+  // the base does not already carry a version segment makes both spellings work.
+  //
+  // The trailing slashes are stripped above, which is what kept `https://api.anthropic.com/v1/` from
+  // becoming `…/v1//messages`.
+  const versioned = protocol === 'anthropic' && !/\/v\d+$/.test(b) ? `${b}/v1` : b;
+  const endpoint = !b ? '' : (protocol === 'anthropic' ? `${versioned}/messages`
+    : protocol === 'responses' ? `${b}/responses`
+    : `${b}/chat/completions`);
 
   // Context window: an explicit env/root override wins, then the model's own
   // `contextLength` (discovered from the provider's /v1/models), then the
@@ -509,6 +509,15 @@ const b = baseUrl.replace(/\/+$/, '');
     // because the two are a matter of taste and the cost is one branch.
     shimmerEdge: String(root.shimmer_edge || process.env.HNCODE_SHIMMER_EDGE || 'cosine').toLowerCase() === 'linear'
       ? 'linear' : 'cosine',
+    // WEB SEARCH KEYS (`web_search_api_key`).
+    //
+    // Keyless mode is rate-limited BY IP, so a shared or busy address gets refusals that look like "search is
+    // broken". Tavily keys are per account and the tool tries them IN ORDER, so the monthly quota is additive.
+    //
+    // The value is a LIST, one key per line. It is kept as a STRING here — newline-separated — because that is
+    // what the multi-line editor edits and what `setConfigString` writes; splitting happens at the call site so
+    // a stray blank line can never count as a key. A single key is a list of one, so an old config still works.
+    webSearchApiKey: String(root.web_search_api_key || process.env.HNCODE_WEB_SEARCH_API_KEY || '').trim(),
     raw: root,
   };
 }

package/src/row-cache.js

@@ -29,6 +29,15 @@
 // what "the same" means. `evictIfStale` is the second half of the same contract: a streamed
 // message's text grows every frame, so an entry whose text no longer matches is not a
 // reuse, and the cache has to notice rather than serve it.
+//
+// THE TEXT IS HASHED, NOT EMBEDDED
+// --------------------------------
+// The first version put the whole message text in the key. Measured: a 1260-character
+// message produced a 1286-character key, so filling the 1500-entry cache held ~7MB of
+// pure key strings — more than the rendered rows they identify. Every lookup also built a
+// fresh megabyte-scale string to compare. A 32-bit hash plus the text LENGTH keeps a key
+// under 60 characters; the length is what makes a collision mean "two texts of the same
+// size hashed alike" rather than "any two texts", and a collision only costs a re-render.
 
 /** How many messages keep their rows. Chosen by measurement, not by feel: the rows for a
  *  typical assistant message are a few hundred bytes each, so 1500 covers a long session's
@@ -36,8 +45,20 @@
 export const ROW_CACHE_LIMIT = 1500;
 
 /**
- * A cache key that identifies a rendered message.
+ * FNV-1a over a string, as an unsigned 32-bit number.
  *
+ * @param {string} s
+ * @returns {number}
+ */
+function hashText(s) {
+  let h = 2166136261 >>> 0;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h >>> 0;
+}
+/**
  * Every input the render reads goes in, so "the same key" means "the same rows":
  *   `id`  a stable identity for the message. Index-based ids break the moment a message
  *         is inserted or removed, which is exactly what compaction and /undo do.
@@ -49,9 +70,17 @@ export const ROW_CACHE_LIMIT = 1500;
  *   spinner key.
  */
 export function makeRowKey(parts) {
+  // THE TEXT IS HASHED, NOT EMBEDDED. Measured: a 1260-character message produced a
+  // 1286-character key, so a full cache held megabytes of key strings — more than the rows
+  // they identify — and every lookup built a fresh one to compare. Hash plus LENGTH keeps a
+  // key around 50 characters. The length is what narrows a collision from "any two texts"
+  // to "two texts of the same size that also hash alike", and a collision costs a re-render,
+  // not a wrong row.
+  const text = parts.text == null ? '' : String(parts.text);
   return [
     parts.id,
-    parts.text == null ? '' : parts.text,
+    text.length,
+    hashText(text),
     parts.w,
     parts.fg,
     parts.codeFg,

package/src/settings-schema.js

@@ -79,8 +79,8 @@ export const SETTINGS_SCHEMA = [
     ui: { tab: 'appearance', group: 'Display', label: 'Calm mode', hint: 'Fewer decorative flourishes; keeps the information, drops the animation' } },
   { key: 'reduced_motion', ...bool(false),
     ui: { tab: 'appearance', group: 'Motion', label: 'Reduced motion', hint: 'No sweeps or pulses — for a terminal over a slow link, or a preference' } },
-  { key: 'render_fps', kind: 'int', default: '30',
-    ui: { tab: 'appearance', group: 'Performance', label: 'Render FPS', hint: 'How often the screen is repainted. 0 means 1 — a terminal cannot render at zero. Higher is smoother and costs more CPU' } },
+  { key: 'render_fps', kind: 'int', default: '30',
+    ui: { tab: 'appearance', group: 'Performance', label: 'Render FPS', hint: 'How often the screen is repainted. 0 means 1 — a terminal cannot render at zero. Higher is smoother and costs more CPU' } },
   { key: 'shimmer_edge', ...bool(true),
     ui: { tab: 'appearance', group: 'Motion', label: 'Shimmer edge', hint: 'The travelling highlight on a running tool name' } },
   { key: 'show_tool_details', ...bool(true),
@@ -151,6 +151,21 @@ export const SETTINGS_SCHEMA = [
     ui: { tab: 'tools', group: 'Delegation', label: 'Swarm mode', hint: 'Expose AgentSwarm for fanning work across subagents' } },
   { key: 'output_style', ...str(''),
     ui: { tab: 'tools', group: 'Output', label: 'Output style', hint: 'Named style overriding how replies are written' } },
+  // THE WEB SEARCH KEYS. Keyless search is rate-limited per IP, so on a shared or busy address WebSearch
+  // answers with refusals that read as "search is broken". Tavily keys are per account, and the tool tries
+  // them in order — several keys make the monthly quota additive.
+  //
+  // `kind: 'text'` is what makes /settings open the multi-line editor instead of asking for one line: the
+  // value IS a list, one key per line.
+  { key: 'web_search_api_key', ...text(''),
+    ui: {
+      tab: 'tools',
+      group: 'Web',
+      label: 'WebSearch API keys',
+      hint: 'One key per line, tried in order — a second key is used when the first is out of quota. '
+        + 'Get them free at https://app.tavily.com (sign in, copy from the dashboard). '
+        + 'Empty uses keyless mode, which is rate-limited per IP.',
+    } },
   { key: 'auto_trim_aggressive', ...bool(false), ui: null },
   { key: 'no_delegation', ...bool(false), ui: null },
 

package/src/team/team.js

@@ -238,10 +238,13 @@ export function leadOf(teamName) {
 /**
  * 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
+ * "THE LEAD" IS A NAME, NOT NECESSARILY A ROSTERED AGENT. `createTeam` records `leadName` — `team-lead` by
+ * default — and `addMember` gives every recruit the plain `member` role. Labelling the first recruit a lead
+ * was tried and reversed: `/team add` recruits someone to DO the work, and the person typing is already in
+ * charge, so a self-styled lead believed nobody had assigned it anything.
+ *
+ * `leadName` may still match a member on the roster, and when it does that member IS the lead and has a full
+ * agent identity — `agentId`, `agentType`, `cwd`, a phase, its own inbox. Sending it 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`,

package/src/tools/ask-user-question.js

@@ -53,6 +53,8 @@ Do NOT use it for what you can infer from context, or for trivial decisions —
 
 Usage:
 - Users always get an "Other" option; do not create one.
+    + 'For an answer that cannot be enumerated (a name, a path, a description), set free_text: true and omit'
+    + ' options — the user gets a focused field instead of a list.',
 - 2-4 distinct options per question, labels 1-5 words, descriptions carry the trade-offs. Labels unique within a question, question texts unique across the call.
 - 1-4 questions at a time, related ones grouped. multi_select allows several answers.
 - Put a recommended option first and append "(Recommended)" to its label.
@@ -105,8 +107,15 @@ export const spec = {
               type: 'boolean',
               description: 'Whether the user can select multiple options.',
             },
+            free_text: {
+              type: 'boolean',
+              description:
+                'Ask for a WRITTEN answer with no options: the field is focused immediately and the reply is'
+                + ' the text typed. Use it when the answer cannot be enumerated — a name, a path, a'
+                + ' description. Omit options when this is true.',
+            },
           },
-          required: ['question', 'options'],
+          required: ['question'],
         },
       },
     },
@@ -139,7 +148,10 @@ export const spec = {
       const text = String((q && q.question) || '').trim();
       if (!text) return 'Error: every question needs a non-empty `question` string.';
       const opts = Array.isArray(q && q.options) ? q.options : [];
-      if (opts.length < MIN_OPTIONS || opts.length > MAX_OPTIONS) {
+      const freeText = !!(q && q.free_text);
+      // A FREE-TEXT QUESTION HAS NO OPTIONS. The 2-4 rule exists so a choice is a real choice; applying it here
+      // would force a question like "what should the release be called?" to invent two decoys first.
+      if (!freeText && (opts.length < MIN_OPTIONS || opts.length > MAX_OPTIONS)) {
         return `Error: question ${JSON.stringify(text)} needs ${MIN_OPTIONS}-${MAX_OPTIONS} options (got ${opts.length}).`;
       }
       const options = [];
@@ -153,9 +165,12 @@ export const spec = {
         header: String((q && q.header) || '').trim().slice(0, 12),
         options,
         multiSelect: !!(q && q.multi_select),
+        // CARRIED THROUGH AS `freeText`, which is the name the dialog reads. Without this the flag stopped at
+        // the tool: the question arrived with no options AND no marker, so the dialog drew the option list —
+        // empty apart from its "Other" row — and the field never opened.
+        freeText,
       });
     }
-
     const dup = questionUniquenessError(questions);
     if (dup) return dup;
 

package/src/tools/edit.js

@@ -28,17 +28,36 @@ import { hashRegion as hashLines } from './read.js';
 
 export const spec = {
   name: 'Edit',
-  description: 'Edit a file. Three shapes: LINE-RANGE (path + start_line + end_line + new_string), SUBSTRING (path + old_string + new_string, unique unless replace_all), RANGED SUBSTRING (the same plus start_line + end_line, which narrows where old_string is searched). \nBOTH BOUNDS ARE INCLUSIVE: start_line=3, end_line=5 replaces lines 3, 4 and 5 — three lines, so new_string must have exactly three lines. A fourth line is a duplicate, not an addition. \nnew_string is VERBATIM: no re-indent, no trim. Every line carries its own leading whitespace, the first one included — copy it from the Read output after the tab that follows each line number. old_string is matched exactly, including its own first-line indentation. \nOmitting new_string is an error. After a multi-line edit, Read the region again: mis-indented code still parses, so a green test is not proof the edit landed where you meant.',
+  description: `Edit a file. Three shapes: LINE-RANGE (path + start_line + end_line + new_string),
+SUBSTRING (path + old_string + new_string, unique unless replace_all), RANGED SUBSTRING (the same plus
+start_line + end_line, which narrows where old_string is searched).
+
+BOTH BOUNDS ARE INCLUSIVE: start_line=3, end_line=5 covers lines 3, 4 and 5 — three lines, so new_string must
+have exactly three lines.
+
+TO DELETE, SEND AN EMPTY new_string. start_line=7, end_line=7 with new_string="" removes line 7 and nothing
+else. That is the ONLY correct way to delete. Restating the next line as the replacement COPIES it, the file
+then holds that line twice, and because the duplicate looks like damage the retry restates another neighbour —
+the duplicates multiply. Never copy a neighbouring line into new_string to stand in for deleting.
+
+new_string is written VERBATIM — no indentation is added, removed or re-derived. Every line carries its own
+leading whitespace, the FIRST one included; copy it from the Read output after the tab that follows each line
+number (Read prints '12' then a tab, then the indented code, so you send the leading spaces yourself).
+
+COUNT FIRST: in line-range mode new_string must have exactly end_line - start_line + 1 lines, and every line
+you write must be one you are replacing. A line outside the range is not deleted and survives as a duplicate.
+
+Omitting new_string entirely is an error — pass "" to delete.`,
   parameters: {
     type: 'object',
     properties: {
       path: { type: 'string', description: 'Path to the file to edit.' },
       old_string: { type: 'string', description: 'Exact text to replace, including whitespace and newlines. Omit for pure line-range mode. COMBINE it with start_line/end_line to replace only the occurrence inside that range.' },
-      new_string: { type: 'string', description: 'Replacement text, written VERBATIM in BOTH modes — no indentation is added, removed, or re-derived. Write the leading spaces on EVERY line yourself, including the FIRST one, copying them from the Read output after its `N\\t` line-number prefix (Read prints `12\\t    return x`, so you send `    return x`). In LINE-RANGE mode it must contain EXACTLY the lines being replaced: a line that sits outside [start_line, end_line] is not deleted, so restating it here leaves a duplicate. In SUBSTRING mode it replaces old_string, which is itself matched exactly including its own indentation.' },
+      new_string: { type: 'string', description: 'Replacement text, written VERBATIM in BOTH modes — no indentation is added, removed, or re-derived. Write the leading spaces on EVERY line yourself, including the FIRST one, copying them from the Read output after its `N\\t` line-number prefix (Read prints `12\\t    return x`, so you send `    return x`). In LINE-RANGE mode it must contain EXACTLY the lines being replaced: a line that sits outside [start_line, end_line] is not deleted, so restating it here leaves a duplicate. Count them first: new_string must have exactly end_line - start_line + 1 lines. In SUBSTRING mode it replaces old_string, which is itself matched exactly including its own indentation.' },
 
       replace_all: { type: 'boolean', default: false, description: 'Replace all occurrences of old_string.' },
       start_line: { type: 'integer', minimum: 1, description: 'PREFERRED MODE. 1-based first line to replace, INCLUSIVE — the range covers start_line and end_line and every line between them. Requires end_line and new_string. With old_string too, it is the first line to SEARCH for it in.' },
-      end_line: { type: 'integer', minimum: 1, description: 'PREFERRED MODE. 1-based last line to replace, INCLUSIVE (requires start_line). start_line=3, end_line=5 replaces lines 3, 4 AND 5 — three lines, so new_string must have three lines. With old_string too, it is the last line to search in.' },
+      end_line: { type: 'integer', minimum: 1, description: 'PREFERRED MODE. 1-based last line to replace, INCLUSIVE (requires start_line). start_line=3, end_line=5 replaces lines 3, 4 AND 5 — three lines, so new_string must have three lines. If your new_string has four, one of them is outside the range and will survive as a duplicate. With old_string too, it is the last line to search in.' },
     },
     // Three accepted shapes:
     //   line-range        start_line + end_line + new_string
@@ -181,14 +200,21 @@ export const spec = {
       const stale = checkStaleRange(p, lines, start, end, ctx);
       if (stale) return stale;
 
-      const inserted = normalizeText(new_string).split('\n');
-      // The lines being REPLACED, captured before the splice. The TUI renders an
-      // Edit's diff from the tool ARGUMENTS, and line-range mode has no
-      // `old_string` to diff against — so without reporting them here the edit
-      // drew NO diff at all (no +/- rows, no +N/-N counts). Reporting them lets
-      // the caller diff the replaced region -> `new_string`.
+      // AN EMPTY new_string DELETES THE RANGE. No line survives, so the replacement is nothing at all.
+      //
+      // `''.split('\n')` is `['']` — ONE EMPTY STRING — not an empty array. The splice therefore replaced the
+      // range with a single blank line, so "delete these lines" left a hole and shifted everything below it.
+      // Deleting has to mean deleting: when there is no replacement text, the range is removed outright.
+      //
+      // This is also the answer to the mistake that keeps appearing in edits: to remove one line, send an EMPTY
+      // new_string over that one line. Restating the neighbour instead copies it, and the file ends up with the
+      // line twice — the duplicate is a symptom of having no delete, not of carelessness.
+      const inserted = new_string === '' ? [] : normalizeText(new_string).split('\n');
+
+      // The lines being REPLACED, captured before the splice. The TUI renders an Edit's diff from the tool
+      // ARGUMENTS, and line-range mode has no `old_string` to diff against — so without reporting them here the
+      // edit drew NO diff at all.
       const replacedText = lines.slice(start - 1, end).join('\n');
-
       const out = [...lines.slice(0, start - 1), ...inserted, ...lines.slice(end)];
       const normUpdated = out.join('\n');
       const updated = eol === '\r\n' ? normUpdated.split('\n').join('\r\n') : normUpdated;
@@ -199,24 +225,12 @@ export const spec = {
         ensureDir(p);
         fs.writeFileSync(p, updated, 'utf8');
       } catch (e) { return `Error writing ${args.path}: ${e.message}`; }
-      refreshReadPool(p, normUpdated, { start, end: start + inserted.length - 1 }, ctx);
+      // NO READ-SNAPSHOT REFRESH. The write changed the file, so every region the model was holding is now a
+      // record of text that no longer exists — including the span just written, whose current content the
+      // model has never seen. Regenerating trust from the arguments would let it edit again on top of a change
+      // it only THINKS it knows. It reads the file instead.
       const removed = end - start + 1;
-      // Publish the diff for the UI. The Edit line is drawn from these, so a
-      // line-range edit shows the same +/- rows and +N/-N counts as a substring
-      // edit instead of nothing. `ctx.lastEditDiff` is consumed (and cleared) by
-      // the agent loop right after this tool returns.
-      //
-      // `lines` is the pre-edit content, which is what `start` indexes into.
-      // The diff's NEW text is `inserted` — what the file now holds — not the
-      // raw `new_string`: when the seam-drop removed a line, the raw text showed a
-      // `+` row that is not in the file and shifted every after-context line
-      // number by the dropped count.
       if (ctx) ctx.lastEditDiff = buildEditDiff({ fileLines: lines, oldText: replacedText, newText: inserted.join('\n'), startLine: start });
-      // Say what the seam did, whichever way it went: a silent drop and a silent keep are both
-      // indistinguishable from an edit that never had the ambiguity. The dropped line is named
-      // with its ACTUAL pair (the two result lines that would have been identical) — it is not
-      // always "the last line of new_string against end_line + 1": a block can carry the repeat
-      // inside itself, with blank lines between the copies.
       return `Edited ${args.path}: replaced lines ${start}-${end} (${removed} line${removed === 1 ? '' : 's'}) with ${inserted.length} line${inserted.length === 1 ? '' : 's'}.`;
     }
 
@@ -350,39 +364,9 @@ export const spec = {
       ensureDir(p);
       fs.writeFileSync(p, updated, 'utf8');
     } catch (e) { return `Error writing ${args.path}: ${e.message}`; }
-    // Silently re-arm the Read snapshot for the edited region so the AI can keep
-    // editing on top of its own change WITHOUT another Read: we recompute the
-    // affected line range + hash from the NEW content and refresh the pool. We
-    // also drop any previously-recorded region whose content no longer matches
-    // (those are genuinely stale now). Nothing here is told to the model.
-    if (ctx && ctx.readPool) {
-      const entry = ctx.readPool.get(p);
-      if (entry) {
-        const newLines = normUpdated.split('\n');
-        entry.fileHash = hashStr(normUpdated);
-        entry.lines = newLines.length;
-        // Locate the edit site in the NEW content: same character offset as the
-        // match in the old one, because the text before the match is untouched.
-        // An anchor taken from the NEW text's first line found the first copy of
-        // that line ANYWHERE in the file (and `indexOf('')` returned 0 for a
-        // deletion), recording the re-armed region at a line the model never edited.
-        if (matchAt >= 0) {
-          const at = normUpdated.slice(0, matchAt).split('\n').length - 1; // 0-based
-          const newSpan = Math.max(1, String(matchNew).split('\n').length);
-          const start = at + 1;
-          const end = Math.min(newLines.length, at + newSpan);
-          // Re-hash every surviving old region against the new content, and add
-          // the freshly-edited span. Regions that no longer match are dropped.
-          const kept = entry.regions.filter((r) => hashLines(newLines, r.start, r.end) === r.hash);
-          kept.push({ start, end, hash: hashLines(newLines, start, end) });
-          entry.regions = kept;
-        } else {
-          // Could not locate the site: drop stale regions so nothing false stays.
-          entry.regions = entry.regions.filter((r) => hashLines(newLines, r.start, r.end) === r.hash);
-        }
-        try { const st = fs.statSync(p); entry.size = st.size; entry.mtimeMs = st.mtimeMs; } catch {}
-      }
-    }
+    // NO READ-SNAPSHOT REFRESH — see the note on the line-range path above. Whatever the model was holding is
+    // now a record of a file that no longer exists, so the next edit of these lines has to be preceded by a
+    // Read of them.
     const occurrences = replace_all ? count : 1;
     // Publish the diff for the UI (same contract as the line-range path above).
     // `startLine` comes from the actual match offset, so a snippet that starts
@@ -622,18 +606,4 @@ function checkStaleRange(p, curLines, start, end, ctx) {
   return `Edit rejected: ${p} changed since it was Read (lines ${start}-${end} are not in an intact Read snapshot). Re-run ${args_readHint(p, start, end - start + 1)} to get the current content, then Edit.`;
 }
 
-// Refresh the region cache after a successful edit: drop regions that no longer
-// match the NEW content, and record the freshly-written span. Mirrors the
-// re-arm block used by the substring path.
-function refreshReadPool(p, normUpdated, written, ctx) {
-  if (!ctx || !ctx.readPool) return;
-  const entry = ctx.readPool.get(p);
-  if (!entry) return;
-  const newLines = normUpdated.split('\n');
-  entry.fileHash = hashStr(normUpdated);
-  entry.lines = newLines.length;
-  const kept = entry.regions.filter((r) => hashLines(newLines, r.start, r.end) === r.hash);
-  kept.push({ start: written.start, end: Math.min(newLines.length, Math.max(written.start, written.end)), hash: hashLines(newLines, written.start, Math.min(newLines.length, Math.max(written.start, written.end))) });
-  entry.regions = kept;
-  try { const st = fs.statSync(p); entry.size = st.size; entry.mtimeMs = st.mtimeMs; } catch {}
-}
+