create-evda 0.1.9 → 0.1.11

package/lib/mcp.mjs

@@ -23,17 +23,21 @@ import * as tools from "./tools.mjs";
 import * as presets from "./presets.mjs";
 import * as gather from "./gather.mjs";
 import * as gatherApply from "./gather-apply.mjs";
+import * as adoptLib from "./adopt.mjs";
 import { checkForUpdate, summarize } from "./update-check.mjs";
 import { callerFrom } from "./readers.mjs";
 import { listSkills, getSkill, writeSkill, noticeRepeat, SKILLS_REL } from "./skills.mjs";
 import { createSubrecord } from "./subrecord.mjs";
 import { FALSIFY } from "./mcp-auth.mjs";
-import { filingOf, FILING_MODES } from "./day-file.mjs";
+import { filingOf, FILING_MODES, entriesAsk } from "./day-file.mjs";
 import { readManifest, writeManifest } from "./manifest.mjs";
 import * as pairing from "./pairing.mjs";
 import { encodeQr, qrPng, qrText } from "./qr.mjs";
 import { splitFence } from "./agents.mjs";
+import { touches, touchesText, warmTouches } from "./touches.mjs";
+import { CLAUDE_AI_LAYER_BUDGET, appNamed } from "./connecting-apps.mjs";
 import { EVERY_CHAT_KEY, EVERY_CHAT_VERSION, CHAT_APPS, chatAppOf, needsEveryChat, everyChatWalkthrough } from "./every-chat.mjs";
+import { newToolsFor, newToolsNotice } from "./connector-tools.mjs";
 
 // Newest first. The server answers with the client's version when it supports it, and with the
 // newest otherwise; the client decides whether to continue.
@@ -55,7 +59,7 @@ export function instructions(filing, surface = "terminal") {
     ...(filing === null ? ["They have not said how filing works yet: evda_operating_layer holds the one question to ask them first, and evda_filing records the answer."] : []),
     "The day's entry is their words verbatim plus one line of context on what the conversation was about, passed as evda_write's context: that line is yours and is labeled as not theirs, and it is never written into words. Where anything else goes (a person's page, a project, the ledger) is your call by the record's four roles, journal, work, collections and knowledge.",
     "When you notice a process repeating (the same steps done or explained a second time, the same correction twice), write it once as a skill with evda_write_skill and tell the owner in one line; read the skills there are with evda_skills and follow the one that fits; when a run of one goes wrong, revise it. A skill is how you work, never a rule about their life.",
-    "When the owner corrects you, record it in the same turn with evda_record_correction: it appends one dated line to AGENTS.md's \"What I have been taught\", in their own words where they gave some, and nothing else in that file changes.",
+    "When the owner corrects you, record it in the same turn with evda_record_correction: it appends one dated entry where this record keeps corrections (the file evda.json names as \"corrections\", else AGENTS.md's \"What I have been taught\"), in their own words where they gave some, and nothing else in that file changes.",
     "When they ask for an EVÐA inside this one (a project, a company, an agent), make it with evda_create_subrecord; it runs doctor and returns the report. Sharing, grants and deletes still wait for their explicit yes.",
     "When they say to just note something, file it with evda_note instead: no AI reads a noted entry, you included, until they say it can, and then evda_release_note clears it. A sealed entry or section is theirs alone: no tool shows it or releases it, and you are never told where it is; when a tool says part of the record is sealed, tell them it is there for them on their own device. When a tool says something was not shown, tell them in one plain sentence what is there and how they open it.",
     ...(filing === "asked" ? [] : ["Filing is expected without being asked: they should never have to say \"save this\", and a conversation that ends with nothing of theirs filed has lost it."]),
@@ -152,28 +156,14 @@ export function terminalOnly(sec) {
   return false;
 }
 
-// The clients this server knows, by initialize's clientInfo.name, and the size of one part for each.
-// Names: claude-code and codex-mcp-client measured 2026-10-05 (a probe server logging clientInfo,
-// driven by `claude -p` and `codex exec`). claude.ai sends Anthropic/ClaudeAI, measured 2026-10-05 in
-// the remote server's log from a fresh web chat; claude-ai stays matched as the published form.
-// openai-mcp is the name ChatGPT publishes and is unmeasured until that log holds one.
-// Limits: claude.ai and the desktop app take a tool result of about 150,000 characters
-// (claude.com/docs/connectors/building, "Design within the size and timeout limits"); Claude Code
-// 25,000 tokens (same page, MAX_MCP_OUTPUT_TOKENS); OpenAI publishes no figure for ChatGPT and
-// truncates an over-budget result at a line, so ChatGPT and every unknown app get the smallest
-// documented cap, LAYER_PART_MAX. Codex documents none either and gets the same.
-export const CLIENTS = [
-  { app: "Claude Code", match: /^claude-code$/i, surface: "terminal", max: LAYER_PART_MAX },
-  { app: "Codex", match: /^codex-mcp-client$/i, surface: "terminal", max: LAYER_PART_MAX },
-  { app: "claude.ai", match: /^(claude-ai|anthropic\/claudeai)$/i, surface: "chat", max: 140_000 },
-  { app: "ChatGPT", match: /^openai-mcp$/i, surface: "chat", max: LAYER_PART_MAX },
-];
-
+// Which app is connecting, and what it is served: the one table in lib/connecting-apps.mjs
+// (HQ-2218), read here by exact name. An app it does not name gets a chat app's sections and the
+// smallest documented part, LAYER_PART_MAX.
+export { CLAUDE_AI_LAYER_BUDGET };
 export function clientProfile(name) {
-  const n = typeof name === "string" ? name.trim() : "";
-  const known = CLIENTS.find((c) => c.match.test(n));
-  if (known) return { app: known.app, surface: known.surface, max: known.max };
-  return { app: null, surface: "chat", max: LAYER_PART_MAX };
+  const known = appNamed(name);
+  if (known) return { app: known.app, surface: known.surface, max: known.max ?? LAYER_PART_MAX, budget: known.budget ?? CHAT_LAYER_BUDGET };
+  return { app: null, surface: "chat", max: LAYER_PART_MAX, budget: CHAT_LAYER_BUDGET };
 }
 
 // The owner layer for one surface: the text without the sections tagged for another, and the
@@ -314,7 +304,7 @@ export function layerParts(evda, client = null) {
   const core = coreBlock(r);
   // Everything in the result but the owner sections: head, size line, core, and the joins between.
   const fixed = head.length + 2 + SIZE_LINE_RESERVE + 2 + core.reduce((n, c) => n + c.length + 2, 0);
-  const fit = profile.surface === "terminal" ? { text: owner.text, listed: [] } : fitChat(owner.text, fixed);
+  const fit = profile.surface === "terminal" ? { text: owner.text, listed: [] } : fitChat(owner.text, fixed, profile.budget);
   const body = [...core, fit.text].join("\n\n");
   const max = profile.max;
   const pieces = packSections(body, max - PART_RESERVE - head.length, max - PART_RESERVE);
@@ -432,7 +422,10 @@ export const CLI_TOOLS = {
 // answer ("ask them once ... and record the answer there").
 // HQ-2228: an entry growing is evda_append (any entry) beside evda_record_person_note (a person's
 // page), and setup ("Write each answer into that section in their exact words") is evda_setup_answer.
-export const CHAT_PROSE_TOOLS = ["evda_operating_layer", "evda_write", "evda_read", "evda_search", "evda_recent", "evda_record_person_note", "evda_append", "evda_setup_answer", "evda_import", "evda_filing"];
+// HQ-2328/HQ-2331: a row in a log kept as a table is evda_append_row, and the page, person's page or
+// folder the core says to offer ("start it only on their yes") is evda_create. HQ-2333: an item in a
+// board or queue kept as a list is evda_append_item.
+export const CHAT_PROSE_TOOLS = ["evda_operating_layer", "evda_write", "evda_read", "evda_search", "evda_recent", "evda_record_person_note", "evda_append", "evda_append_row", "evda_append_item", "evda_create", "evda_setup_answer", "evda_import", "evda_filing"];
 
 // The tool names a text tells an agent to use: evda_* names and `evda <command>` runs.
 export function toolsNamedIn(text) {
@@ -467,6 +460,10 @@ export function firstSentence(text) {
 // The one setup question, asked at first connect when evda.json has no filing answer (HQ-1385).
 export const FILING_QUESTION = "Should I file everything you say here automatically, or only when you ask? (everything)";
 
+// HQ-2326: on 2026-10-07 a claude.ai chat worked out a real read of what he asked, wrote it into a
+// person's page, and replied with only the filing report. In a chat the reply is where he hears it.
+export const REPLY_FIRST_LINE = "- Your reply carries your thinking and your answer. Report filing after it, in one line; a page you write never replaces saying it to them here.";
+
 // The few lines a chat app reads before the whole operating layer (HQ-1385): who the agent is,
 // whether to file, one section per conversation, no share marks or circle rules, and "just note".
 // Five lines, and a sixth that asks the setup question when the owner has not answered it.
@@ -508,7 +505,8 @@ export function chatSection(evda, agentsText = "", { app = null } = {}) {
     "- One conversation is one section: your first evda_write opens it with one line of context, and the rest go under it.",
     "- Never write a share mark or a circle rule. When they want to share, propose it and wait for their yes.",
     "- \"Just note this\" means evda_note: no AI reads that entry, you included, until they say it can.",
-    "- When a person, project or place that already has an entry comes up, add a dated section to it with evda_append (a person's page with evda_record_person_note). Neither creates or overwrites anything.",
+    "- When a person, project or place that already has an entry comes up, add a dated section to it with evda_append (a person's page with evda_record_person_note). Neither creates or overwrites anything. A log or board kept as a table grows by a row (evda_append_row), and one kept as a list by an item in its format (evda_append_item).",
+    REPLY_FIRST_LINE,
   ];
   // HQ-2164: what the agent itself did goes to its own day log. Named here, so a chat app is offered
   // the tool (chatToolNames offers what this layer names), and only when the record has that log.
@@ -604,7 +602,7 @@ export const TOOLS = [
     // HQ-2223, slice 2: the first sentence holds the words a model searches by when it starts a chat
     // as the owner's agent (who you are, the owner's record, a new chat), and this is the one tool
     // whose definition says "operating layer", so a search for it finds this tool and no other.
-    description: "Loads the operating layer: who you are for the owner and how their record is kept, to read at the start of every new chat before your first reply. Pass the owner's first message as first_message (and context, one line on what the chat is about) and it is filed verbatim in this same call, exactly as evda_write files it, and the result also carries their unseen replies and the recent days' headings, so you can answer after this one call. Returns how to act here, a few lines for a chat app, what leaves this device, the core of how the agent thinks, and then AGENTS.md (who the agent is, what this EVDA is for in the owner's words, and how the record is kept). A long layer comes in parts; read every part before answering. In a chat app, owner sections past a size budget are listed by heading; pass section to read one whole.",
+    description: "Loads the operating layer: who you are for the owner and how their record is kept, to read at the start of every new chat before your first reply. Pass the owner's first message as first_message (and context, one line on what the chat is about) and it is filed verbatim in this same call, exactly as evda_write files it, and the result also carries their unseen replies, the recent days (each section's context and the opening of their words) and the people whose pages grew this week, so you can answer after this one call. Returns how to act here, a few lines for a chat app, what leaves this device, the core of how the agent thinks, and then AGENTS.md (who the agent is, what this EVDA is for in the owner's words, and how the record is kept). A long layer comes in parts; read every part before answering. In a chat app, owner sections past a size budget are listed by heading; pass section to read one whole.",
     inputSchema: {
       type: "object",
       properties: {
@@ -634,22 +632,20 @@ export const TOOLS = [
       if (!Number.isInteger(part) || part < 1 || part > l.parts.length) throw tools.refuse(`evda_operating_layer "part" is a whole number from 1 to ${l.parts.length}; this layer has ${l.parts.length === 1 ? "one part" : `${l.parts.length} parts`}.`, "BAD_ARGUMENT");
       const data = { path: l.path, core: l.core, part, parts: l.parts.length, chars: l.chars, listed: l.listed };
       if (!opening) return { text: l.parts[part - 1], data };
-      const start = openChat(evda, args, ctx);
+      const start = openChat(evda, args, ctx, { room: clientProfile(ctx.client?.name).max - l.parts[part - 1].length - 7 - AFTER_RUN_RESERVE });
       return { text: `${l.parts[part - 1]}\n\n---\n\n${start.text}`, data: { ...data, filed: start.filed } };
     },
   },
   {
     name: "evda_recent",
     title: "Read the last few days",
-    description: "Lists the record's files from the last few days by path and headings. N days (default 3), newest first, never a word of the body. Read a specific one whole with evda_read, by the path this returns. Each file says what an earlier reader already acknowledged in it, which you do not raise again.",
+    description: "Lists what the record's last few days were about. Per file, each section's heading, its context line and the opening of the owner's words; N days (default 3), newest first. Read a specific one whole with evda_read, by the path this returns. Each file says what an earlier reader already acknowledged in it, which you do not raise again.",
     inputSchema: { type: "object", properties: { days: { type: "integer", minimum: 1, maximum: 90, description: "How many days back, today included. Default 3." } }, additionalProperties: false },
     annotations: { readOnlyHint: true, openWorldHint: false },
     run: (evda, args, ctx) => {
       const r = tools.recent(evda, args, { caller: ctx.caller, now: ctx.now });
-      const body = r.files.map((f) => `<file path="${f.path}" date="${f.date}"${ackAttr(f.acknowledged)}>${f.headings.length ? `\n${f.headings.map((h) => `# ${h}`).join("\n")}` : ""}\n</file>`).join("\n\n");
-      const head = `${r.files.length} file(s) dated ${r.from} to ${r.to}, headings only, no body text (read one whole with evda_read when the question needs it)${r.omitted ? `, ${r.omitted} more omitted for size (read them with evda_search)` : ""}.${r.acknowledged ? ` ${acknowledgedNote(r.acknowledged)}` : ""}`;
-      const main = r.files.length ? `${head}\n\n${body}` : `Nothing${r.refused.length ? " you may read" : ""} in the record is dated ${r.from} to ${r.to}.`;
-      return { text: r.heldBack ? `${main}\n\n${r.heldBack}` : main, data: { from: r.from, to: r.to, paths: r.files.map((f) => f.path), omitted: r.omitted, acknowledged: r.acknowledged } };
+      const room = ctx.room ?? clientProfile(ctx.client?.name).max - PART_RESERVE;
+      return renderRecent(r, room);
     },
   },
   {
@@ -700,18 +696,20 @@ export const TOOLS = [
       // returning, so a clobbered write is never reported to the owner as "Filed".
       const r = await tools.writeVerified(evda, args, { session: ctx.session });
       markWrite(ctx.session, args.words, r.path);
-      return { text: `Filed to ${r.path}.`, data: r };
+      if (r.queued) return { text: queuedText(r), data: r };
+      return withTouches(evda, ctx, { text: `Filed to ${r.path}.`, data: r }, { path: r.path, words: [args.context, args.words].filter(Boolean).join("\n") });
     },
   },
   {
     name: "evda_record_correction",
     title: "Record a correction",
-    description: "Records a correction as one dated line in what the agent has been taught. Call when the owner corrects you (\"no, don't do that\", \"that's not how I work anymore\"): appends one dated line to AGENTS.md's \"What I have been taught\" section, in the owner's own words where they gave some, and returns the path. That section is always outside the installer's block, so `evda upgrade` never touches what this writes. Append only: it never edits or removes an earlier entry. When a correction reverses one, pass supersedes with that entry's date instead of trying to change it.",
+    description: "Records a correction as one dated entry in what the agent has been taught. Call when the owner corrects you (\"no, don't do that\", \"that's not how I work anymore\"): appends a dated section to the file evda.json names as \"corrections\" when it names one, else one dated line to AGENTS.md's \"What I have been taught\" section, in the owner's own words where they gave some, and returns the path. That section is always outside the installer's block, so `evda upgrade` never touches what this writes. Append only: it never edits or removes an earlier entry. When a correction reverses one, pass supersedes with that entry's date instead of trying to change it.",
     inputSchema: {
       type: "object",
       properties: {
         words: str("The owner's exact words, quoted verbatim, when they gave some. Omit rather than paraphrase."),
         change: str("One line: what you do differently now."),
+        title: str("A few words naming what went wrong, e.g. \"missed the midterm when checking a week\". The entry's heading when corrections go to their own file."),
         supersedes: str("YYYY-MM-DD of an earlier entry this correction reverses, if any."),
       },
       required: ["change"],
@@ -719,25 +717,29 @@ export const TOOLS = [
     },
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
     run: (evda, args, ctx) => {
-      const r = tools.recordCorrection(evda, args);
+      const r = tools.recordCorrection(evda, args, { caller: ctx.caller });
       return { text: `Recorded to ${r.path}, under "${r.section}".`, data: r };
     },
   },
   {
     name: "evda_write_agent_log",
     title: "File Iris's own day log",
-    description: "Files the agent's own day log, separate from the owner's words. Call to record what you (the agent, not the owner) did, built, filed or found: appends to Iris's own day log, the one named sub-record at \"01_Projects/Evda/Iris - Universal Thinking Partner/memory/record/daily\", and returns the path. It takes no path and reaches nowhere else. One section per conversation, exactly like evda_write: the first call in a conversation opens the time heading with its context line, and later calls in the same conversation continue it.",
+    description: "Files the agent's own day log, separate from the owner's words. Call to record what you (the agent, not the owner) did, built, filed or found: appends to Iris's own day log, the one named sub-record at \"01_Projects/Evda/Iris - Universal Thinking Partner/memory/record/daily\", and returns the path. It takes no path. It also keeps the one pointer line to that log under the agent's heading in the owner's day for today (added, or refreshed in place, never a second line), and touches nothing else there. One section per conversation, exactly like evda_write: the first call in a conversation opens the time heading with its context line, and later calls in the same conversation continue it.",
     inputSchema: { type: "object", properties: { words: str("What you did, in your own words."), context: str("One line on what the conversation was about. Written above the words and labeled as not the owner's.") }, required: ["words"], additionalProperties: false },
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
     run: (evda, args, ctx) => {
       const r = tools.writeAgentLog(evda, args, { session: ctx.session });
-      return { text: `Filed to ${r.path}.`, data: r };
+      const p = r.pointer;
+      const pointer = p.state === "failed" ? ` The pointer line in ${p.path} was NOT written (${p.error}); the log entry is filed, so do not call this again for it.`
+        : p.state === "sealed" ? ` ${p.path} is sealed, so its pointer line was left alone.`
+        : ` Pointer line in ${p.path} ${p.state}.`;
+      return { text: `Filed to ${r.path}.${pointer}`, data: r };
     },
   },
   {
     name: "evda_record_person_note",
     title: "Add to a person's page",
-    description: "Adds one dated section to an existing person's page, found by their name. The page is under the record/people role; returns the path. Resolves the page by the name you give, not a path; refuses when no page matches (it never creates one; offer to make the page first) and when more than one page matches. Refuses a sealed page. When the page's frontmatter is kind: person-profile, also adds a matching observations entry so the page still passes evda doctor. Append only: an earlier section is never edited or removed.",
+    description: "Adds one dated section to an existing person's page, found by their name. Returns the path. A person's page is any page with kind: person-profile frontmatter wherever it is in the record (a Family folder, a second people folder), or any page in the people folder; the name you give matches its filename, its name: or an alias, with or without a trailing parenthetical. Refuses when no page matches (it never creates one; offer to make the page first) and when more than one page matches (say which). Refuses a sealed page, a just-noted page and one in a part set to be read by a different AI. When the page's frontmatter is kind: person-profile, also adds a matching observations entry so the page still passes evda doctor. Append only: an earlier section is never edited or removed.",
     inputSchema: {
       type: "object",
       properties: {
@@ -749,20 +751,22 @@ export const TOOLS = [
       additionalProperties: false,
     },
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
-    run: (evda, args) => {
-      const r = tools.recordPersonNote(evda, args);
-      return { text: `Added to ${r.path}${r.observation ? `, observation ${r.observation}` : ""}.`, data: r };
+    run: (evda, args, ctx) => {
+      const r = tools.recordPersonNote(evda, args, { caller: ctx.caller });
+      return withTouches(evda, ctx, { text: `Added to ${r.path}${r.observation ? `, observation ${r.observation}` : ""}.`, data: r }, { path: r.path, words: [args.context, args.words].filter(Boolean).join("\n") });
     },
   },
   {
     name: "evda_append",
     title: "Add to an existing entry",
-    description: "Adds one dated section to an entry that already exists, by its path. Call when a project, place or other entry the record already has comes up again: appends `## YYYY-MM-DD` and the words to the end of that file, or continues today's section when it is already the last one, and returns the path. Every byte already there stays as it was. Refuses a path with no entry (it never creates one; offer to start the page), a sealed entry, a just-noted entry, a part set to be read by a different AI, and anything shaped like a password, key or token. A person's page goes through evda_record_person_note, the day's words through evda_write.",
+    description: "Adds one dated section to an entry that already exists, by its path. Call when a project, place or other entry the record already has comes up again: appends `## YYYY-MM-DD` and the words to the end of that file, or continues today's section when it is already the last one, and returns the path. With under, the section goes at the end of that heading's section instead (so a new item lands in the queue, not under \"Completed\"), its heading one level below. With title, the heading is `<title> (added YYYY-MM-DD)`. Every byte already there stays as it was. Refuses a path with no entry (start one with evda_create, on their yes), a sealed entry, a just-noted entry, a part set to be read by a different AI, and anything shaped like a password, key or token. A row in a table goes in with evda_append_row, an item in a list with evda_append_item, a person's page through evda_record_person_note, the day's words through evda_write.",
     inputSchema: {
       type: "object",
       properties: {
         path: str("The existing entry, relative to the record, as evda_search or evda_recent gave it."),
         words: str("The new section's words. Their experience in their words; never another person's motive stated as fact."),
+        under: str("Optional: the text of a heading in that file, without the #s. The section goes at the end of that heading's section instead of the end of the file."),
+        title: str("Optional, one line: what the section is. The heading becomes `<title> (added YYYY-MM-DD)`."),
       },
       required: ["path", "words"],
       additionalProperties: false,
@@ -770,7 +774,73 @@ export const TOOLS = [
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
     run: (evda, args, ctx) => {
       const r = tools.appendEntry(evda, args, { caller: ctx.caller });
-      return { text: r.section === "continued" ? `Added to the ${r.date} section of ${r.path} (continued).` : `Added a ${r.date} section to ${r.path}.`, data: r };
+      const under = r.under ? ` under "${r.under}"` : "";
+      return withTouches(evda, ctx, { text: r.section === "continued" ? `Added to the ${r.date} section of ${r.path}${under} (continued).` : `Added a ${r.date} section to ${r.path}${under}.`, data: r }, { path: r.path, words: [args.title, args.words].filter(Boolean).join("\n") });
+    },
+  },
+  {
+    name: "evda_append_row",
+    title: "Add a row to a table",
+    description: "Adds one row to a table in an entry that already exists, by its path. Call when the owner reports something kept as a table (a food log, a spike log, a word list): the row goes at the end of that table, its cells in the table's column order, and every other byte of the file stays as it was. Returns the path and the row written. A file with more than one table needs under, the heading whose section holds the table meant. Refuses a row whose cell count is not the table's column count, a cell with a line break, a path with no entry, a sealed or just-noted entry, a part set to be read by a different AI, and anything shaped like a password, key or token.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: str("The existing entry, relative to the record, as evda_search or evda_recent gave it."),
+        cells: { type: "array", items: { type: "string" }, description: "The row's cells in the table's column order, one string each, \"\" for an empty cell. Their words where the column holds their words." },
+        under: str("Optional: the text of the heading whose section holds the table, without the #s. Needed when the file has more than one table."),
+      },
+      required: ["path", "cells"],
+      additionalProperties: false,
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    run: (evda, args, ctx) => {
+      const r = tools.appendRow(evda, args, { caller: ctx.caller });
+      return withTouches(evda, ctx, { text: `Added a row to ${r.path}: ${r.row}`, data: r }, { path: r.path, words: (args.cells ?? []).join("\n") });
+    },
+  },
+  {
+    name: "evda_append_item",
+    title: "Add an item to a list",
+    description: "Adds one item to a list in an existing entry. Call when the owner reports something kept as a list of one-line items (a board of weekends or trips, a queue, a reading list): read the list first and write the line in the format its items use, and it goes in after the last item with the list's own marker (the next number in a numbered list), or with after right after the item that names, so a list kept in order stays in order; every other byte of the file is kept. Returns the path and the item written. A file with more than one list needs under, the heading whose section holds the list meant. Refuses a line with a line break, a path with no entry, a section with no list (a new section is evda_append), a sealed or just-noted entry, a part set to be read by a different AI, and anything shaped like a password, key or token.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: str("The existing entry, relative to the record, as evda_search or evda_recent gave it."),
+        line: str("The new item, one line, without its marker, in the format the list's other items use. Their words where the list holds their words."),
+        under: str("Optional: the text of the heading whose section holds the list, without the #s. Needed when the file has more than one list."),
+        after: str("Optional: a piece of the text of the item the new one goes right after, as it is written there (for a dated list, the item it follows in date order). Without it the item goes at the end."),
+      },
+      required: ["path", "line"],
+      additionalProperties: false,
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    run: (evda, args, ctx) => {
+      const r = tools.appendItem(evda, args, { caller: ctx.caller });
+      return withTouches(evda, ctx, { text: `Added an item to ${r.path}: ${r.item}`, data: r }, { path: r.path, words: args.line });
+    },
+  },
+  {
+    name: "evda_create",
+    title: "Start a new page or folder",
+    description: "Starts a new page, person's page or folder in the record, on the owner's yes. Call after you offered in one line to start an entry that does not exist yet (\"want me to start a page for X?\") and they said yes in this conversation; pass confirmed: true only then. kind \"page\" makes a Markdown page at path with a title and, with words, a first dated section; kind \"person\" makes their page in the people folder under their name, with the person-profile frontmatter doctor reads and, with context and words, a first section and its observation; kind \"folder\" makes one empty folder. Returns the path. Refuses a path that already exists (it never overwrites), a path outside the record, the record's own files, a folder that is not there yet for the page, a part that is sealed or set to be read by a different AI, and anything shaped like a password, key or token.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        kind: { type: "string", enum: tools.CREATE_KINDS, description: "page, person, or folder." },
+        path: str("For a page or folder: where, relative to the record. A page ends in .md, and the folder it goes in must exist."),
+        person: str("For a person's page: their name, as the page should be called."),
+        title: str("For a page: its title. Defaults to the file name."),
+        context: str("For a person's page, with words: one line on what the first section is. Becomes its heading and the observation's text."),
+        words: str("The first section's words, in the owner's words. Optional."),
+        confirmed: { type: "boolean", description: "true only when the owner said yes to starting this in this conversation." },
+      },
+      required: ["kind", "confirmed"],
+      additionalProperties: false,
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    run: (evda, args, ctx) => {
+      const r = tools.createEntry(evda, args, { caller: ctx.caller });
+      return { text: `Created ${r.kind === "folder" ? "the folder" : "the page"} ${r.path}${r.observation ? `, observation ${r.observation}` : ""}.`, data: r };
     },
   },
   {
@@ -833,6 +903,28 @@ export const TOOLS = [
       return { text: `<file path="${r.path}">\n${r.text}\n</file>${r.truncated ? "\n(truncated for size)" : ""}` };
     }),
   },
+  // HQ-2066: the phone's editor saves through this, the Mac's save safety on the writer. It is in no
+  // chat set (CHAT_PROSE_TOOLS), so a chat app is never offered a tool that replaces a note.
+  {
+    name: "evda_replace",
+    title: "Save the owner's edit of one note",
+    description: "Replaces one note's whole text with the owner's edit, only when the note is unchanged since it was read. Call only to save an edit the owner made by hand, as the phone's editor does: pass the path, the whole new text, and base, the SHA-256 in hex of the text evda_read returned. Refuses, with nothing written, a note changed since (read it again and edit what is there now), a missing note, a note with a sealed section or too long to read whole, a sealed, just-noted or other-AI note, the record's own files, and a new line shaped like a password, key or token. Returns the path and the saved text's SHA-256, the base for the next save.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: str("The note, relative to the record, as evda_read gave it."),
+        text: { type: "string", description: "The note's whole new text, exactly as the owner left it." },
+        base: str("The SHA-256, in hex, of the text evda_read returned for this note."),
+      },
+      required: ["path", "text", "base"],
+      additionalProperties: false,
+    },
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    run: (evda, args, ctx) => {
+      const r = tools.replaceNote(evda, args, { caller: ctx.caller });
+      return { text: `${r.changed ? "Saved" : "Nothing to save in"} ${r.path}. version ${r.version}`, data: r };
+    },
+  },
   {
     name: "evda_note",
     title: "Just note something",
@@ -1064,6 +1156,30 @@ export const TOOLS = [
       return { text: r.lines.join("\n") };
     },
   },
+  {
+    name: "evda_adopt",
+    title: "Adopt a folder of notes where it is",
+    description: "Makes a folder of notes the owner already keeps (an old Iris Vault, an Obsidian vault) an EVÐA in place: nothing moves. It maps the folders already there to the record's roles (an Iris Vault without asking), writes evda.json, AGENTS.md, .evda/ and the Claude Code hooks, and adds one @AGENTS.md line to the end of their CLAUDE.md; every other file stays byte for byte. Call it with dry: true first: it returns the mapping and names each folder it cannot place. Ask the owner about each of those one at a time, in your own words, and pass their answers as map. Ask whether everything they say should be filed automatically or only when they ask, and pass it as filing. Call it without dry only after they said yes to the mapping in this conversation, with confirmed: true. It runs doctor and names the reversal manifest that `evda adopt --revert` undoes byte for byte; tell them that path.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        dir: str("The folder to adopt, as a path on this machine."),
+        map: { type: "object", additionalProperties: { type: "string" }, description: "The owner's answers: folder (relative to dir) -> role (record/daily, record/captures, record/people, journal, collections, knowledge, work, each with an optional /facet, or none)." },
+        filing: { type: "string", enum: ["everything", "asked"], description: "The owner's answer: file everything they say, or only when asked." },
+        owner: str("The owner's name, as they gave it."),
+        dry: { type: "boolean", description: "true to see the mapping and the open questions; writes nothing." },
+        confirmed: { type: "boolean", description: "true only when the owner said yes to adopting this folder with this mapping in this conversation." },
+      },
+      required: ["dir"],
+      additionalProperties: false,
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    run: (evda, args) => {
+      const r = adoptLib.adoptTool(args);
+      if (r.dry) return { text: [...r.lines, "", r.questions.length ? `Open questions, ask them one at a time:\n${r.questions.map((q) => `- ${q}`).join("\n")}` : "No open questions. Nothing was written; adopt it with confirmed: true after the owner's yes."].join("\n") };
+      return { text: [...r.lines, "", ...adoptLib.connectLines(r.dir, args.filing ?? null)].join("\n") };
+    },
+  },
   {
     name: "evda_skills",
     title: "List or read the agent's skills",
@@ -1283,22 +1399,158 @@ const RECEIVED = new Set(["evda_import", "evda_gather_answer"]);
 const WRITES = new Set(["evda_write", "evda_note"]);
 
 export function newSession() {
-  return { calls: 0, reads: 0, received: 0, writes: 0, lastNudge: -Infinity, layer: false, preambled: false, lastCall: null, everyChatAsked: false, lastFiled: null };
+  return { calls: 0, reads: 0, received: 0, writes: 0, lastNudge: -Infinity, layer: false, preambled: false, lastCall: null, everyChatAsked: false, lastFiled: null, agentWork: [], agentLogged: false, agentLogNudged: false, sections: {}, named: [], namedTickets: [], wrotePaths: [], entriesAsked: false };
 }
 
+// The agent-log nudge (HQ-2329). In Claude Code a Stop hook makes the agent log what it did; a chat
+// app has none, and measured 2026-10-07 claude.ai made 2 evda_write_agent_log calls in 13 sessions
+// against 14 from Claude Code: the 10/7 test chat wrote a person page, the Deep Work Queue and the
+// journal and logged none of it. So once a chat has written something beyond the owner's words, the
+// result of that write says what to log, once per conversation, and never after the chat has logged.
+// A write tool counts unless it is named here: the owner's own words (filed by the layer, a read, a
+// search, evda_write, evda_note), setup answers, device pairing and the log itself. A write tool
+// added later counts without anyone remembering to add it.
+// EVDA_RECORD_FALSIFY=no-agent-log-nudge turns it off, for the control test.
+const NOT_AGENT_WORK = new Set([
+  "evda_operating_layer", "evda_write", "evda_note", "evda_write_agent_log", "evda_search", "evda_read", "evda_replies",
+  "evda_acknowledge", "evda_import", "evda_filing", "evda_every_chat", "evda_setup_answer", "evda_release_note",
+  "evda_gather", "evda_gather_answer", "evda_pair", "evda_finish_pairing", "evda_sync_devices", "evda_remove_device", "evda_check_update",
+]);
+export function isAgentWork(tool) {
+  return Boolean(tool) && tool.annotations?.readOnlyHint === false && !NOT_AGENT_WORK.has(tool.name);
+}
+export function agentLogNudge(paths) {
+  const what = paths.length ? `wrote to ${paths.join(", ")}` : "changed the record";
+  return `You ${what} in this conversation, beyond the owner's words, and your own day log has nothing from this conversation yet. Before you answer, say what you did (built, filed, fixed, found) in a sentence or two with evda_write_agent_log, with one line of context. Only once per conversation is this said.`;
+}
+
+// The named-entries ask (HQ-2799). A write's answer names the existing entries its words bear on
+// (withTouches); nothing checked that any was acted on, and on 2026-10-21 a named project page was
+// never opened. So the server keeps, per chat, what it named and what was written, and the first
+// result after one named entries, while none of them has been written to, asks once, naming them and
+// saying that adding nothing is fine: the agent judges. Quiet after a write to any of them or after
+// asking once. Never for an owner who files only when they ask (HQ-1385). Open tickets the answer
+// named (HQ-2798) are listed in the ask too; the board is another server's, so this one cannot see a
+// ticket being updated, and only a write to a named entry answers the ask here.
+// EVDA_RECORD_FALSIFY=no-entries-ask turns it off, for the control test.
+export function countEntries(session, r, { filing = null, env = process.env } = {}) {
+  if (!r || r.isError) return null;
+  session.named ??= [];
+  session.wrotePaths ??= [];
+  const path = typeof r.data?.path === "string" ? r.data.path : null;
+  if (path && !session.wrotePaths.includes(path)) session.wrotePaths.push(path);
+  const answered = () => session.named.some((n) => session.wrotePaths.includes(n.path));
+  let ask = null;
+  session.namedTickets ??= [];
+  if ((session.named.length || session.namedTickets.length) && !answered() && !session.entriesAsked && filing !== "asked" && !(env.EVDA_RECORD_FALSIFY ?? "").split(",").map((m) => m.trim()).includes("no-entries-ask")) {
+    session.entriesAsked = true;
+    ask = entriesAsk(session.named.map((n) => n.path), undefined, session.namedTickets);
+  }
+  for (const n of r.data?.touches?.related ?? []) if (!session.named.some((x) => x.path === n.path)) session.named.push({ path: n.path, name: n.name });
+  for (const k of r.data?.touches?.tickets ?? []) if (k?.id && !session.namedTickets.includes(k.id)) session.namedTickets.push(k.id);
+  return ask;
+}
+
+// Count one call toward the agent-log nudge and say whether its result carries it. `hasLog` is
+// whether the record has the agent log at all; with none, there is nothing to nudge toward.
+export function countAgentWork(session, tool, r, { hasLog, env = process.env } = {}) {
+  if (tool?.name === "evda_write_agent_log" && !r?.isError) { session.agentLogged = true; return null; }
+  if (!isAgentWork(tool) || r?.isError) return null;
+  const path = typeof r?.data?.path === "string" ? r.data.path : null;
+  if (path && !session.agentWork.includes(path)) session.agentWork.push(path);
+  if (!path && !session.agentWork.length) session.agentWork.push(null);
+  if (!hasLog || session.agentLogged || session.agentLogNudged) return null;
+  if ((env.EVDA_RECORD_FALSIFY ?? "").split(",").map((m) => m.trim()).includes("no-agent-log-nudge")) return null;
+  session.agentLogNudged = true;
+  return agentLogNudge(session.agentWork.filter(Boolean));
+}
+
+// The recent days as a chat reads them (HQ-2324): per file, each section's heading, its context line
+// in parentheses and the opening of the owner's words after ">". Measured 2026-10-07 on his record:
+// 3 days were 13 files and 3,181 characters as headings, and most headings were times, so a chat
+// knew when he wrote and not what. It fits `room` characters: every file by heading first, then
+// sections gain their context and opening newest first (newest file, and its last section first,
+// since a day file grows downward) while they fit, so an over-full window loses detail on its
+// oldest sections before it loses a file.
+const sectionLine = (s, rich) => [s.heading !== null ? `# ${s.heading}` : null, rich && s.context ? `(${s.context})` : null, rich && s.opening ? `> ${s.opening}` : null].filter(Boolean).join("\n");
+const fileOpen = (f) => `<file path="${f.path}" date="${f.date}"${ackAttr(f.acknowledged)}>`;
+function renderFiles(files, rich) {
+  return files.map((f, i) => {
+    const lines = f.sections.map((s, j) => sectionLine(s, rich[i].has(j))).filter(Boolean);
+    return `${fileOpen(f)}${lines.length ? `\n${lines.join("\n")}` : ""}\n</file>`;
+  }).join("\n\n");
+}
+
+export function renderRecent(r, room = Infinity) {
+  const files = r.files.map((f) => ({ ...f, sections: f.sections ?? f.headings.map((h) => ({ heading: h, context: null, opening: null })) }));
+  const head = (shown, thin, cut) => `${shown.length} file(s) dated ${r.from} to ${r.to}, newest first: each section's heading, its context line in parentheses and the opening of the owner's words after ">" (read one whole with evda_read when the question needs it)${thin ? `; the oldest ${thin} section(s) by heading only, for size` : ""}${r.omitted + cut ? `, ${r.omitted + cut} more file(s) omitted for size (read them with evda_search)` : ""}.${r.acknowledged ? ` ${acknowledgedNote(r.acknowledged)}` : ""}`;
+  const tail = r.heldBack ? `\n\n${r.heldBack}` : "";
+  if (!files.length) return { text: `Nothing${r.refused.length ? " you may read" : ""} in the record is dated ${r.from} to ${r.to}.${tail}`, data: { from: r.from, to: r.to, paths: [], omitted: r.omitted, acknowledged: r.acknowledged } };
+  const reserve = head(files, 99999, 99999).length + tail.length + 4;
+  // Every file by heading, dropping the oldest while even that is over the room.
+  let shown = files.slice();
+  const none = () => shown.map(() => new Set());
+  while (shown.length > 1 && reserve + renderFiles(shown, none()).length > room) shown.pop();
+  const rich = none();
+  let size = reserve + renderFiles(shown, rich).length;
+  let thin = 0;
+  for (let i = 0; i < shown.length; i++) {
+    for (let j = shown[i].sections.length - 1; j >= 0; j--) {
+      const s = shown[i].sections[j];
+      const grow = sectionLine(s, true).length - sectionLine(s, false).length + (s.heading === null && !sectionLine(s, false) ? 1 : 0);
+      if (grow === 0) continue;
+      if (size + grow <= room) { rich[i].add(j); size += grow; } else thin += 1;
+    }
+  }
+  const cut = files.length - shown.length;
+  const text = `${head(shown, thin, cut)}\n\n${renderFiles(shown, rich)}${tail}`;
+  return { text, data: { from: r.from, to: r.to, paths: shown.map((f) => f.path), omitted: r.omitted + cut, acknowledged: r.acknowledged } };
+}
+
+// The people whose pages grew this week (HQ-2324), in at most `room` characters, newest first.
+export function renderPeople(p, room = Infinity) {
+  if (!p.people.length) return "";
+  const block = (x) => `<person name="${x.name.replace(/"/g, "&quot;")}" path="${x.path}">\n${x.sections.map((s) => sectionLine(s, true)).join("\n")}${x.more ? `\n(${x.more} more dated section(s) this week: read the page with evda_read)` : ""}\n</person>`;
+  const top = `## People whose pages grew this week\n\nDated sections added ${p.from} to ${p.to}, newest first. Read a page whole with evda_read when the conversation turns to them.`;
+  const out = [];
+  let size = top.length;
+  for (const x of p.people) {
+    const b = block(x);
+    if (size + b.length + 2 > room) break;
+    out.push(b);
+    size += b.length + 2;
+  }
+  return out.length ? `${top}\n\n${out.join("\n\n")}` : "";
+}
+
+// The people window: a week, so a chat knows who his last week was about (HQ-2324, 10/7: the 10/2
+// question about chemistry was five days back, outside the three-day recent window).
+export const PEOPLE_DAYS = 7;
+// What handle() adds after a tool's own text on the same result: the every-chat walkthrough (about
+// 1,400 characters, measured 2026-10-07 for ChatGPT), the nudge, the repeat notice.
+const AFTER_RUN_RESERVE = 3_000;
+
 // The one-call start (HQ-2223, slice 2). Measured 2026-10-05: a fresh claude.ai chat took 5 tool
 // calls before it replied, each its own Allow click. So the layer call takes the owner's first
 // message and files it the way evda_write does (same day file, same section for the chat, same
 // refusals), and returns what a chat reads next (unseen replies, the recent days' headings), so the
 // chat can answer after one call. An owner who turned automatic filing off, or has not answered
 // yet, is filed for only when they ask: nothing is written and the result says so.
-export function openChat(evda, args, ctx) {
+// `room` is what the client's result has left after the layer part this rides on (HQ-2324): the
+// replies come whole, then the people block and the recent days share what is left.
+export function openChat(evda, args, ctx, { room = LAYER_PART_MAX } = {}) {
   const f = fileAlong(evda, { words: args.first_message, context: args.context }, ctx, "evda_operating_layer");
   const head = f.filed
     ? `Filed their first message to ${f.path}. Tell them in the past tense, and file each later message with evda_write; this one is already filed.`
     : f.head;
   const run = (name) => TOOLS.find((t) => t.name === name).run(evda, {}, ctx).text;
-  const parts = [head, `## Their replies you have not seen\n\n${run("evda_replies")}`, `## The last few days\n\n${run("evda_recent")}`];
+  const replies = `## Their replies you have not seen\n\n${run("evda_replies")}`;
+  const DAYS = "## The last few days\n\n";
+  let left = room - head.length - replies.length - DAYS.length - 8;
+  const people = renderPeople(tools.recentPeople(evda, { days: PEOPLE_DAYS, caller: ctx.caller, now: ctx.now }), Math.floor(left / 3));
+  left -= people.length + 2;
+  const recent = renderRecent(tools.recent(evda, {}, { caller: ctx.caller, now: ctx.now }), left).text;
+  const parts = [head, replies, `${DAYS}${recent}`, ...(people ? [people] : [])];
   return { text: parts.join("\n\n"), filed: f.filed ? f.path : null };
 }
 
@@ -1336,6 +1588,7 @@ export function fileAlong(evda, { words, context }, ctx, toolName) {
       ctx.session.writes += 1;
       ctx.session.lastFiled = { words: words.trim(), path: r.path, by: "along" };
     }
+    if (r.queued) return { filed: true, queued: true, path: r.path, head: queuedText(r) };
     return { filed: true, path: r.path, head: `Filed their message to ${r.path}.` };
   } catch (e) {
     if (!(e instanceof EvdaError) || e.code !== "SECRET") throw e;
@@ -1343,6 +1596,21 @@ export function fileAlong(evda, { words, context }, ctx, toolName) {
   }
 }
 
+// What a filing bears on (HQ-2631): the existing entries the filed words name and the shared circles
+// they and the written path reach, and the open board tickets they reference when the work role is a
+// board (HQ-2798), appended to a write tool's answer as information. Empty adds nothing.
+export function withTouches(evda, ctx, out, { path, words }) {
+  const t = touches(evda, { paths: [path], words, caller: ctx.caller ?? callerFrom() });
+  const block = touchesText(t);
+  return block ? { text: `${out.text}\n\n${block}`, data: { ...out.data, touches: { related: t.related, circles: t.circles, tickets: t.tickets ?? [] } } } : out;
+}
+
+// What an evda_write held by EVDA_DAY_WRITE_GATE says (HQ-2596): queued, where, and why, so the
+// agent tells the owner the truth and does not call it again (a second call queues a second copy).
+function queuedText(r) {
+  return `Queued, not filed yet: this machine is holding writes to the day (${r.held}). Their words wait at ${r.path} and are filed into the day, in order, once its copy has synced. Tell them the words are queued, not filed, and do not call evda_write again for them.`;
+}
+
 // Whether these words are the ones last filed in this chat (fileAlong's rule). evda_write passes
 // spend: true and matches only a ride-along's mark, and spends it either way.
 export function sameAsFiled(session, words, { spend = true } = {}) {
@@ -1368,10 +1636,20 @@ function markWrite(session, words, path) {
 // a new chat taken for an old one, would leave it with no layer and no nudge.
 export const CHAT_IDLE_MS = 20 * 60 * 1000;
 
-function enterChat(session, now) {
-  if (session.lastCall !== null && now - session.lastCall > CHAT_IDLE_MS) {
-    Object.assign(session, newSession());
-  }
+// HQ-2330: claude.ai also sends one session id into chats only minutes apart (2026-10-07, Hestia:
+// session 57ff531a served the 20:24 chat, the 20:30 chat and the 20:38 test chat), and no header or
+// parameter it sends names the conversation. What does mark one is the call every chat starts with:
+// evda_operating_layer, the layer the server's instructions and the tool's own description say to
+// read at the start of a new chat. So a layer call for its start (part 1, no section: a long layer's
+// later parts and a section read are the same chat reading on) after anything else on the session
+// starts a new chat too: nothing filed, nothing logged, and the next write opens its own section. A chat that
+// reloads the layer mid-way costs one new section, which carries its context line; the other error,
+// two chats in one section, files one chat's words under the other's heading.
+const opensLayer = (args) => (args?.part === undefined || args.part === 1) && args?.section === undefined;
+function enterChat(session, now, name, args, env) {
+  const idle = session.lastCall !== null && now - session.lastCall > CHAT_IDLE_MS;
+  const restart = name === "evda_operating_layer" && opensLayer(args) && session.calls > 0 && !chatFalsified("no-layer-boundary", env);
+  if (idle || restart) Object.assign(session, newSession());
   session.lastCall = now;
 }
 
@@ -1381,8 +1659,8 @@ function enterChat(session, now) {
 // chat get one line until the layer is loaded. Returns "preamble", "reminder" or null.
 // EVDA_CHAT_FALSIFY=no-layer-preamble turns it off, for the control test.
 export const LAYER_REMINDER = "evda_operating_layer is still not loaded in this conversation: call it before you answer, so you answer as who you are here.";
-export function layerNotice(session, name, { env = process.env, now = Date.now() } = {}) {
-  enterChat(session, now);
+export function layerNotice(session, name, { env = process.env, now = Date.now(), args = {} } = {}) {
+  enterChat(session, now, name, args, env);
   if (name === "evda_operating_layer") { session.layer = true; return null; }
   if (session.layer || chatFalsified("no-layer-preamble", env)) return null;
   if (session.preambled) return "reminder";
@@ -1428,6 +1706,24 @@ export function countCall(session, name, { env = process.env, filing = null } =
   return true;
 }
 
+// The new-tools notice (HQ-2205, lib/connector-tools.mjs): once per connection, on its first tool
+// call, a chat app's offered names are compared with every name it was offered before on this
+// record. It rides in the tail, so a refused call carries it too: the refusal may be the very
+// permission it is about. A coding agent (offered null) sets its own permissions and is skipped.
+// It writes the record's .evda/connector-tools.json, so only a server keeps it: serve() and
+// lib/mcp-http.mjs set ctx.keepsToolList, and a caller of handle() that did not ask writes nothing.
+// EVDA_CHAT_FALSIFY=no-new-tools turns it off, for the control test.
+export function toolListNotice(ctx, evda, env = ctx.env ?? process.env) {
+  if (ctx.toolsChecked) return null;
+  ctx.toolsChecked = true;
+  if (!ctx.keepsToolList || !ctx.app || chatFalsified("no-new-tools", env)) return null;
+  const names = offered(ctx);
+  if (!names) return null;
+  const added = newToolsFor(evda, ctx.app, names, { now: new Date(ctx.clock?.() ?? Date.now()) });
+  if (!added.length) return null;
+  return newToolsNotice(ctx.app, added, Object.fromEntries(TOOLS.map((t) => [t.name, t.title])));
+}
+
 // The tools this client is offered: every tool for a coding agent, the chat set for any other.
 // A record that cannot be opened offers the chat set's fixed part.
 function offered(ctx) {
@@ -1463,6 +1759,8 @@ export async function handle(msg, ctx) {
         // Which chat app, for the every-chat walkthrough only (HQ-2205). It decides which words are
         // shown, never what may be read, so a client that misnames itself costs nothing but wording.
         ctx.app = chatAppOf(p.clientInfo?.name ?? null);
+        // HQ-2631: index the record's names after this answer, so the first filing does not wait.
+        try { const e = typeof ctx.evda === "function" ? ctx.evda() : null; if (e?.dir) warmTouches(e); } catch { /* the first filing builds it */ }
         return ok({
           protocolVersion: PROTOCOL_VERSIONS.includes(asked) ? asked : PROTOCOL_VERSIONS[0],
           capabilities: { tools: { listChanged: false }, resources: { listChanged: false, subscribe: false } },
@@ -1486,10 +1784,14 @@ export async function handle(msg, ctx) {
           if (!ctx.caller) ctx.caller = callerFrom({ env: ctx.env ?? process.env });
           ctx.session ??= newSession();
           const evda = ctx.evda();
-          const notice = layerNotice(ctx.session, tool.name, { env: process.env, now: ctx.clock?.() ?? Date.now() });
+          const notice = layerNotice(ctx.session, tool.name, { env: process.env, now: ctx.clock?.() ?? Date.now(), args });
           tail = notice === "preamble" ? `\n\n---\n\n${layerPreamble(evda)}` : notice === "reminder" ? `\n\n${LAYER_REMINDER}` : "";
+          const added = toolListNotice(ctx, evda);
+          if (added) tail += `\n\n---\n\n${added}`;
           const r = await tool.run(evda, args, ctx);
           const nudge = countCall(ctx.session, tool.name, { filing: filingOf(evda.manifest) }) ? `\n\n${NUDGE}` : "";
+          const logNudge = countAgentWork(ctx.session, tool, r, { hasLog: tools.hasAgentLog(evda) });
+          const entries = countEntries(ctx.session, r, { filing: filingOf(evda.manifest) });
           // evda_filing just changed the answer the walkthrough's line depends on, so it reads it again.
           const setup = r.isError ? null : everyChatNotice(ctx.session, ctx.app, tool.name === "evda_filing" ? ctx.evda().manifest : evda.manifest, tool.name);
           // A process run twice is pointed at once (HQ-1377), so an agent in an app with no memory of
@@ -1500,7 +1802,7 @@ export async function handle(msg, ctx) {
           // so everything the model needs, paths included, is in the text.
           // An image (evda_pair's QR code, HQ-2040) follows the text; everything the model needs is still in the text.
           const images = (r.images ?? []).map((i) => ({ type: "image", data: i.data, mimeType: i.mimeType }));
-          return ok({ content: [{ type: "text", text: `${r.text}${tail}${setup ? `\n\n---\n\n${setup}` : ""}${nudge}${repeat ? `\n\n${repeat}` : ""}` }, ...images], isError: Boolean(r.isError) });
+          return ok({ content: [{ type: "text", text: `${r.text}${tail}${setup ? `\n\n---\n\n${setup}` : ""}${nudge}${logNudge ? `\n\n${logNudge}` : ""}${entries ? `\n\n${entries}` : ""}${repeat ? `\n\n${repeat}` : ""}` }, ...images], isError: Boolean(r.isError) });
         } catch (e) {
           // A refusal is a tool result the model reads and acts on, not a protocol failure.
           if (e instanceof EvdaError) return ok({ content: [{ type: "text", text: `${e.message}${tail}` }], isError: true });
@@ -1542,7 +1844,7 @@ function error(id, code, message) {
 // Serve on stdio until stdin closes. `dir` is the located record; it is reopened for every call so
 // a record edited by hand between calls is read as it is now.
 export function serve({ dir, version, input = process.stdin, output = process.stdout, log = (s) => process.stderr.write(`[evda mcp] ${s}\n`) }) {
-  const ctx = { version, log, evda: () => openEvda(dir), session: newSession() };
+  const ctx = { version, log, evda: () => openEvda(dir), session: newSession(), keepsToolList: true };
   openEvda(dir); // refuse to start on something that is not a record
   log(`serving ${dir} (tool schema ${SCHEMA_VERSION})`);
   const rl = createInterface({ input, crlfDelay: Infinity });