create-evda 0.1.11 → 0.1.12

package/CHANGELOG.md

@@ -4,6 +4,17 @@ Plain-English notes on how Iris behaves differently after each version. Not a co
 
 ## Unreleased
 
+What the owner taught Iris now reaches every app: evda_operating_layer ends with the newest entries of the corrections file evda.json names (or of AGENTS.md's "What I have been taught" when a chat's size budget lists that section), the same on every surface, within the layer's budget, and only to a reader allowed to read that file.
+
+On a machine that sends the owner's messages to another machine to file, one Claude Code session is one section of the day again, under one heading with one context line, instead of a new heading for every message: the prompt hook names its session with each send, and `evda_write` and `evda_write_agent_log` take that as `conversation` and keep its section between separate calls, in `~/.evda/conversations` (`EVDA_CONVERSATION_DIR`) outside the record (HQ-2823).
+
+The Claude Code read guard now runs from a copy inside the record (`.claude/hooks/evda-guard/`), like the other two hooks, so it keeps working after the npx cache or checkout that installed it is gone; a reinstall replaces any older guard entry instead of adding a second one, and `evda doctor` fails when a registered guard's file is missing (HQ-2819).
+
+The Claude Code prompt hook no longer files Claude Code's own text as the owner's words. A background
+task's completion (a `<task-notification>` block) is not filed at all, and a `<system-reminder>`
+block added to a real message is left out of what is filed; a message with neither stays byte for
+byte (HQ-2823).
+
 On a machine that does not write the day (`EVDA_DAY_WRITER` set), the Claude Code prompt hook no
 longer appends to the local day file. It sends each message to the writer through the command in
 `EVDA_DAY_WRITER_SEND` (evda_write's arguments as JSON on stdin), and a message the writer cannot take

package/README.md

@@ -12,7 +12,7 @@ The AI you choose reads what it needs to think with you. With training turned of
 
 If you want more than that, you have two options. You can run a model locally on your own computer, and you can just ask how to set it up. Or you can say something is just to be noted, and no AI reads it until you say it can.
 
-**Who reads what.** Setup writes the AI you chose into `evda.json` as `read_by`, so it reads the whole record. A circle can name its own reader: another AI, `local` for a model on your own hardware (`evda local-model` says how), or `none`. `evda doctor` prints "Read by" for every part. Say "just note this" and your agent files it with `noted: true` (`evda note` from a terminal); no AI reads it until you say it can (`evda release <path>`), and `evda search` still finds it on your device. The MCP server refuses both in code, `hooks/evda-read-guard.mjs` (installed into the record for Claude owners) stops Claude Code's Read, Grep and shell reads of them, and `AGENTS.md` tells every other agent to decline out loud. None of this is a lock: the words are plain files on your disk, and it stops an agent that checks.
+**Who reads what.** Setup writes the AI you chose into `evda.json` as `read_by`, so it reads the whole record. A circle can name its own reader: another AI, `local` for a model on your own hardware (`evda local-model` says how), or `none`. `evda doctor` prints "Read by" for every part. Say "just note this" and your agent files it with `noted: true` (`evda note` from a terminal); no AI reads it until you say it can (`evda release <path>`), and `evda search` still finds it on your device. The MCP server refuses both in code, `hooks/evda-read-guard.mjs` (copied into the record's `.claude/hooks/evda-guard/` for Claude owners) stops Claude Code's Read, Grep and shell reads of them, and `AGENTS.md` tells every other agent to decline out loud. None of this is a lock: the words are plain files on your disk, and it stops an agent that checks.
 
 EVÐA prescribes no values and no rules. The only requirement is that you want to, and you are open to it. It is built on a neo-Aristotelian philosophy; ask your agent about it, or have any agent verify it by reading this code.
 

package/bin/evda.mjs

@@ -554,7 +554,7 @@ async function main(argv) {
       const ph = hooks.promptHookStatus(dir);
       console.log(ph.registered ? (ph.file ? (ph.current ? `prompt hook installed and current: ${hooks.SETTINGS_REL} runs ${hooks.PROMPT_HOOK_REL}` : "prompt hook installed, older than the shipped hook: run `evda hook install`") : `prompt hook registered, but ${hooks.PROMPT_HOOK_REL} is missing: run \`evda hook install\``) : "prompt hook not installed (it is only for an owner who chose to file everything)");
       const g = guardStatus(dir);
-      console.log(g.registered ? (g.file ? `read guard installed: ${hooks.SETTINGS_REL} runs ${g.target ?? "evda guard through npx"}` : `read guard registered, but ${g.target} is missing: run \`evda hook install\``) : "read guard not installed: run `evda hook install`");
+      console.log(g.registered ? (g.file ? `read guard installed: ${hooks.SETTINGS_REL} runs ${g.target ?? "evda guard through npx"}` : `read guard registered, but ${g.missing.join(", ")} is missing: run \`evda hook install\``) : "read guard not installed: run `evda hook install`");
       return st.registered && st.file && st.current && g.registered && g.file && (!ph.registered || (ph.file && ph.current)) ? 0 : 1;
     }
 

package/lib/connect.mjs

@@ -34,50 +34,114 @@ export function serverCommand(recordDir, { execPath = process.execPath, bin = jo
   return { command: stableNode(execPath, env), args: [real, "mcp", dir] };
 }
 
-// The command Claude Code runs for the read guard (lib/guard.mjs), by the same rule as the server:
-// absolute paths when the package is installed somewhere stable, the npx form from an npx cache.
-export function guardCommand({ execPath = process.execPath, hook = join(PACKAGE_ROOT, "hooks", "evda-read-guard.mjs"), env = process.env } = {}) {
-  let real = hook;
-  try { real = realpathSync(hook); } catch { /* not on disk yet, as in a test */ }
-  const q = (s) => (/^[A-Za-z0-9_./:@=+-]+$/.test(s) ? s : `'${String(s).replace(/'/g, "'\\''")}'`);
-  if (/[\\/]_npx[\\/]/.test(real)) return "npx -y -p create-evda@latest evda guard";
-  return `${q(stableNode(execPath, env))} ${q(real)}`;
+// The read guard (lib/guard.mjs) runs from a copy inside the record, like the keep-record and prompt
+// hooks (lib/hooks.mjs), never from the package that installed it (HQ-2819). An absolute path into
+// the installer dies with it: the npx cache npm clears, a checkout or worktree that is removed. The
+// npx form (`npx -y -p create-evda@latest evda guard`) outlives the installer but asks the registry
+// before every Read, and an offline laptop then runs no guard, so it is not written either. The copy
+// is the entry point plus every lib/ file it imports, found by walking the imports at install time,
+// so a new import in lib/guard.mjs is copied without anyone listing it.
+export const GUARD_DIR_REL = ".claude/hooks/evda-guard";
+export const GUARD_REL = `${GUARD_DIR_REL}/evda-read-guard.mjs`;
+export const GUARD_COMMAND = `node "$CLAUDE_PROJECT_DIR/${GUARD_REL}"`;
+export const GUARD_MATCHER = "Read|Grep|Bash|NotebookRead";
+const SHIPPED_GUARD = join(PACKAGE_ROOT, "hooks", "evda-read-guard.mjs");
+const LIB_DIR = join(PACKAGE_ROOT, "lib");
+
+// Every file the record's copy of the guard holds, as [path in the record, bytes]. The entry point
+// is the shipped one with its one import pointed at the lib/ copied beside it; the lib files are
+// byte for byte. Throws if the shipped entry no longer imports ../lib/guard.mjs, so a change there
+// cannot install a copy that fails at load.
+export function guardFiles() {
+  const entry = readFileSync(SHIPPED_GUARD, "utf8");
+  const IMPORT = 'from "../lib/guard.mjs"';
+  if (!entry.includes(IMPORT)) throw new Error(`${SHIPPED_GUARD} no longer imports ../lib/guard.mjs, so the guard copy cannot be built`);
+  const files = [[GUARD_REL, Buffer.from(entry.replace(IMPORT, 'from "./lib/guard.mjs"'))]];
+  const seen = new Set();
+  const walk = (name) => {
+    if (seen.has(name)) return;
+    seen.add(name);
+    const bytes = readFileSync(join(LIB_DIR, name));
+    files.push([`${GUARD_DIR_REL}/lib/${name}`, bytes]);
+    for (const m of bytes.toString("utf8").matchAll(/\bfrom\s*["']\.\/([^"']+)["']|\bimport\s*\(?\s*["']\.\/([^"']+)["']/g)) walk(m[1] ?? m[2]);
+  };
+  walk("guard.mjs");
+  return files;
 }
 
-// Install the read guard into one record's .claude/settings.json, for Claude Code sessions opened
-// in that folder. Merges into a settings file that is already there: an existing PreToolUse entry
-// with the same command is left alone, and nothing else in the file is touched.
-export function installGuard(recordDir, { command = guardCommand() } = {}) {
-  const path = join(resolve(recordDir), ".claude", "settings.json");
+// The settings commands that run the guard, in any form an installer ever wrote: this copy, an
+// absolute path to some package's hooks/evda-read-guard.mjs, or the npx form.
+export const GUARD_MARK = /evda-read-guard\.mjs|\bevda guard\b/;
+const isGuard = (h) => typeof h?.command === "string" && GUARD_MARK.test(h.command);
+
+// Install the read guard into one record: copy its files into .claude/hooks/evda-guard/ and make
+// .claude/settings.json run that copy. Every guard entry already there (a stale absolute path, the
+// npx form, a duplicate from a second install) is removed, so exactly one remains. Nothing else in
+// the settings file is touched, and a file that already says exactly this is not rewritten.
+export function installGuard(recordDir) {
+  const dir = resolve(recordDir);
+  const path = join(dir, ".claude", "settings.json");
   let settings = {};
   if (existsSync(path)) {
     try { settings = JSON.parse(readFileSync(path, "utf8")); } catch { return { path, action: "left alone (not valid JSON):" }; }
+    if (settings === null || typeof settings !== "object" || Array.isArray(settings)) return { path, action: "left alone (not a JSON object):" };
+  }
+  let copied = false;
+  for (const [rel, bytes] of guardFiles()) {
+    const abs = join(dir, rel);
+    if (existsSync(abs) && readFileSync(abs).equals(bytes)) continue;
+    mkdirSync(dirname(abs), { recursive: true });
+    writeFileSync(abs, bytes);
+    copied = true;
   }
-  const pre = (settings.hooks ??= {}).PreToolUse ??= [];
-  if (pre.some((m) => (m.hooks ?? []).some((h) => h.command === command))) return { path, action: "already installed:" };
-  pre.push({ matcher: "Read|Grep|Bash|NotebookRead", hooks: [{ type: "command", command }] });
+  const pre = Array.isArray(settings.hooks?.PreToolUse) ? settings.hooks.PreToolUse : [];
+  const found = pre.flatMap((m) => (Array.isArray(m?.hooks) ? m.hooks : []).filter(isGuard).map((h) => h.command));
+  if (found.length === 1 && found[0] === GUARD_COMMAND) return { path, action: copied ? "updated the guard copy:" : "already installed:" };
+  const kept = pre
+    .map((m) => (Array.isArray(m?.hooks) && m.hooks.some(isGuard) ? { ...m, hooks: m.hooks.filter((h) => !isGuard(h)) } : m))
+    .filter((m) => !Array.isArray(m?.hooks) || m.hooks.length);
+  kept.push({ matcher: GUARD_MATCHER, hooks: [{ type: "command", command: GUARD_COMMAND }] });
+  if (settings.hooks === null || typeof settings.hooks !== "object" || Array.isArray(settings.hooks)) settings.hooks = {};
+  settings.hooks.PreToolUse = kept;
   mkdirSync(dirname(path), { recursive: true });
   writeFileSync(path, JSON.stringify(settings, null, 2) + "\n");
-  return { path, action: "installed" };
+  return { path, action: found.length ? `replaced ${found.length} older guard ${found.length === 1 ? "entry" : "entries"}:` : "installed" };
 }
 
-// Whether one record's .claude/settings.json runs the read guard, for doctor (HQ-1377):
-// { registered, target, file, problem }. `target` is the hook file the command names, `file` whether
-// it is on disk; the npx form names no file and is present whenever it is registered. Never throws.
-export const GUARD_MARK = /evda-read-guard\.mjs|\bevda guard\b/;
+// The hook file one guard command runs, resolved against the record ($CLAUDE_PROJECT_DIR is the
+// record, since the guard is registered in the record's own settings). Null for the npx form.
+export function guardTarget(command, recordDir) {
+  const dir = resolve(recordDir);
+  const m = /"([^"]*evda-read-guard\.mjs)"|'([^']*evda-read-guard\.mjs)'|(\S*evda-read-guard\.mjs)/.exec(command);
+  if (!m) return null;
+  return resolve(dir, (m[1] ?? m[2] ?? m[3]).replace(/\$\{CLAUDE_PROJECT_DIR\}|\$CLAUDE_PROJECT_DIR/g, () => dir));
+}
+
+// Whether one record's .claude/settings.json runs the read guard, for doctor (HQ-1377, HQ-2819):
+// { registered, target, file, missing, count, current, problem }. `target` is the hook file the
+// first entry names, `missing` every registered file not on disk (`file` is true when there is
+// none), `count` how many guard entries there are, `current` whether the record's copy matches what
+// ships. The npx form names no file and is present whenever it is registered. Never throws.
 // EVDA_HOOKS_FALSIFY=blind reports no guard at all, for the test that shows doctor's line is read
 // from the settings file.
 export function guardStatus(recordDir) {
-  if ((process.env.EVDA_HOOKS_FALSIFY ?? "").split(",").map((x) => x.trim()).includes("blind")) return { registered: false, target: null, file: false, problem: null };
-  const path = join(resolve(recordDir), ".claude", "settings.json");
-  if (!existsSync(path)) return { registered: false, target: null, file: false, problem: null };
+  const none = { registered: false, target: null, file: false, missing: [], count: 0, current: false, problem: null };
+  if ((process.env.EVDA_HOOKS_FALSIFY ?? "").split(",").map((x) => x.trim()).includes("blind")) return none;
+  const dir = resolve(recordDir);
+  const path = join(dir, ".claude", "settings.json");
+  if (!existsSync(path)) return none;
   let settings;
-  try { settings = JSON.parse(readFileSync(path, "utf8")); } catch (e) { return { registered: false, target: null, file: false, problem: `.claude/settings.json is not valid JSON (${e.message}), so no hook in it runs.` }; }
-  const commands = (settings?.hooks?.PreToolUse ?? []).flatMap((m) => (m?.hooks ?? []).map((h) => h?.command)).filter((c) => typeof c === "string" && GUARD_MARK.test(c));
-  if (!commands.length) return { registered: false, target: null, file: false, problem: null };
-  const m = /'([^']*evda-read-guard\.mjs)'|(\S*evda-read-guard\.mjs)/.exec(commands[0]);
-  const target = m ? (m[1] ?? m[2]) : null;
-  return { registered: true, target, file: target === null || existsSync(target), problem: null };
+  try { settings = JSON.parse(readFileSync(path, "utf8")); } catch (e) { return { ...none, problem: `.claude/settings.json is not valid JSON (${e.message}), so no hook in it runs.` }; }
+  const pre = settings?.hooks?.PreToolUse;
+  const commands = (Array.isArray(pre) ? pre : []).flatMap((m) => (Array.isArray(m?.hooks) ? m.hooks : []).filter(isGuard).map((h) => h.command));
+  if (!commands.length) return none;
+  const targets = commands.map((c) => guardTarget(c, dir));
+  const missing = targets.filter((t) => t !== null && !existsSync(t));
+  let current = true;
+  if (targets.includes(join(dir, GUARD_REL))) {
+    try { current = guardFiles().every(([rel, bytes]) => existsSync(join(dir, rel)) && readFileSync(join(dir, rel)).equals(bytes)); } catch { current = false; }
+  }
+  return { registered: true, target: targets[0], file: missing.length === 0, missing, count: commands.length, current, problem: null };
 }
 
 // A `node` on PATH that is this same binary, when there is one: Homebrew's /opt/homebrew/bin/node

package/lib/conversation.mjs

@@ -0,0 +1,68 @@
+// A conversation's section state kept between separate evda_write calls (HQ-2823).
+//
+// appendToDay (lib/day-file.mjs) keeps one conversation in one section through a `session` object,
+// and an MCP process holds that object in memory. A relay that spawns a fresh `evda mcp` for every
+// message (Hestia's evda-tool.mjs, which the prompt hook on a non-writer laptop sends through) has
+// no memory between calls, so on 2026-10-22 every message the owner sent from his laptop opened
+// its own `## HH:MM`. A caller that names its conversation (evda_write's `conversation`) gets the
+// section state loaded from and saved to one small file here instead.
+//
+// Where: EVDA_CONVERSATION_DIR, default ~/.evda/conversations: outside the record and outside any
+// synced folder, the way the prompt outbox is (lib/prompt-hook.mjs promptOutboxDir). What: the
+// `sections` appendToDay keeps, which hold the section's own text so the next write can find it.
+// That is the owner's words outside the record, so the folder is the owner's alone (0700) and a
+// file not written for CONVERSATION_KEEP_MS is deleted on the next save. A section lives in one
+// day's file, so a conversation older than that has nothing left to continue. Age is the
+// `savedAt` written inside each file by the same clock that judges it, never the file's mtime:
+// a clock the OS does not share (a shifted test clock, a restored backup) would otherwise read a
+// file saved a moment ago as old and delete a live conversation.
+
+import { mkdirSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { isConversationId } from "./day-file.mjs";
+
+export const CONVERSATION_DIR_ENV = "EVDA_CONVERSATION_DIR";
+export const CONVERSATION_KEEP_MS = 2 * 24 * 60 * 60 * 1000;
+
+export function conversationDir(env = process.env) {
+  return env[CONVERSATION_DIR_ENV] || join(homedir(), ".evda", "conversations");
+}
+
+const fileOf = (id, env) => join(conversationDir(env), `${id}.json`);
+
+// The session object appendToDay takes for conversation `id`: { sections } as last saved, or {}.
+export function loadConversation(id, { env = process.env } = {}) {
+  if (!isConversationId(id)) throw new Error(`not a conversation id: ${JSON.stringify(id)}`);
+  try {
+    const s = JSON.parse(readFileSync(fileOf(id, env), "utf8"));
+    return s && typeof s.sections === "object" && s.sections ? { sections: s.sections } : {};
+  } catch { return {}; }
+}
+
+// Save it (written whole, then renamed into place, so a reader never sees half a file), and delete
+// every conversation not saved for CONVERSATION_KEEP_MS.
+export function saveConversation(id, session, { env = process.env, nowMs = Date.now() } = {}) {
+  if (!isConversationId(id)) throw new Error(`not a conversation id: ${JSON.stringify(id)}`);
+  const dir = conversationDir(env);
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const abs = fileOf(id, env);
+  const part = `${abs}.${process.pid}.part`;
+  writeFileSync(part, JSON.stringify({ sections: session.sections ?? {}, savedAt: nowMs }) + "\n", { mode: 0o600 });
+  renameSync(part, abs);
+  for (const n of readdirSync(dir)) {
+    const f = join(dir, n);
+    if (f === abs) continue;
+    try { if (nowMs - savedAtOf(f) > CONVERSATION_KEEP_MS) unlinkSync(f); } catch { /* gone already */ }
+  }
+}
+
+// When `f` was saved: its own savedAt, or its mtime for a file written without one (a leftover
+// .part, a file from before savedAt existed).
+function savedAtOf(f) {
+  try {
+    const t = JSON.parse(readFileSync(f, "utf8")).savedAt;
+    if (Number.isFinite(t)) return t;
+  } catch { /* not a whole conversation file */ }
+  return statSync(f).mtimeMs;
+}

package/lib/corrections.mjs

@@ -8,9 +8,11 @@
 // every correction from a chat app was refused and lost. Doctor reads the same setting through this
 // one function, so the tool and the check cannot disagree on what a valid setting is.
 
-import { existsSync, statSync } from "node:fs";
-import { isAbsolute, relative, resolve, sep } from "node:path";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { isSealed } from "./circles.mjs";
+import { readContext, mayRead, aiView } from "./readers.mjs";
+import { datalessAmong } from "./sync-rules.mjs";
 
 export const CORRECTIONS_KEY = "corrections";
 
@@ -32,3 +34,76 @@ export function correctionsTarget(evda) {
   if (isSealed(abs)) return { rel, abs, problem: `"${CORRECTIONS_KEY}" names ${rel}, which is sealed, so no agent writes a correction into it.` };
   return { rel, abs, problem: null };
 }
+
+// What the owner taught the agent, served in the operating layer (HQ-2818). A chat app learns who
+// it is only from evda_operating_layer, so a correction written to a separate corrections file was
+// recorded and never read back on any chat surface. The layer now carries the newest entries, the
+// same selection on every surface, so a correction made in one app reaches the next chat in any.
+//
+// The size is fixed, not the whole file: his file measured 671,346 characters and 445 sections on
+// 2026-10-22, ten times a chat's whole budget. Entries are the file's `## ` sections in file order
+// (evda_record_correction appends, so the last is the newest); the newest are kept whole while they
+// fit, and the block says how many older ones the file holds and how to find one.
+export const CORRECTIONS_LAYER_MAX = 8_000;
+export const TAUGHT_HEADING = "What I have been taught";
+
+// A corrections file's entries: its `## ` sections, in file order. The text before the first one is
+// the file's own preamble, not an entry.
+export function fileEntries(text) {
+  return text.split(/^(?=## )/m).filter((sec) => sec.startsWith("## ")).map((sec) => sec.replace(/\s+$/, ""));
+}
+
+// The "What I have been taught" section's entries: its `- ` lines, each with any lines under it.
+export function sectionEntries(sec) {
+  const body = sec.split("\n").slice(1).join("\n");
+  return body.split(/^(?=- )/m).filter((e) => e.startsWith("- ")).map((e) => e.replace(/\s+$/, ""));
+}
+
+// The newest entries that fit in `max` characters joined by blank lines, oldest of them first.
+// When even the newest is longer, it is cut at a line and says where the rest is.
+export function newestEntries(entries, max, where) {
+  const kept = [];
+  let size = 0;
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const grow = entries[i].length + (kept.length ? 2 : 0);
+    if (size + grow > max) break;
+    kept.unshift(entries[i]);
+    size += grow;
+  }
+  if (!kept.length && entries.length) {
+    const tail = `\n(This entry is cut here; it continues in ${where}.)`;
+    const e = entries[entries.length - 1];
+    let cut = e.slice(0, Math.max(0, max - tail.length));
+    const at = cut.lastIndexOf("\n");
+    if (at > 0) cut = cut.slice(0, at);
+    return { kept: [cut + tail], older: entries.length - 1 };
+  }
+  return { kept, older: entries.length - kept.length };
+}
+
+function block(path, entries, max) {
+  if (!entries.length) return null;
+  const { kept, older } = newestEntries(entries, max, path);
+  const more = older ? ` ${older} older ${older === 1 ? "entry is" : "entries are"} in ${path}; evda_search finds one by its words.` : "";
+  const head = `## ${TAUGHT_HEADING} (from ${path})\n\nWhat the owner corrected you on, newest last, word for word as ${path} keeps it: how they want you to work, learned from real misses.${more}`;
+  return { text: `${head}\n\n${kept.join("\n\n")}\n`, path, served: kept.length, total: entries.length };
+}
+
+// The corrections block for the layer, or null when there is nothing to add. `caller` is who reads
+// the layer: a file this caller may not read (sealed, noted, or a read_by that is not theirs) is not
+// served, by the same mayRead every read tool uses, and a sealed section inside it is never shown.
+// A file still in the cloud is not read, since reading it would start a download.
+//
+// With no "corrections" setting the entries live in AGENTS.md's own section, which the layer already
+// serves, so nothing is added; `taughtListed` is that section's text when a chat's budget listed it
+// by heading instead, and then its newest lines are served here so they still reach the chat.
+export function correctionsForLayer(evda, caller, { max = CORRECTIONS_LAYER_MAX, taughtListed = null, agentsPath = "AGENTS.md" } = {}) {
+  const target = correctionsTarget(evda);
+  if (!target) return taughtListed ? block(agentsPath, sectionEntries(taughtListed), max) : null;
+  if (target.problem) return null;
+  if (!mayRead(readContext(evda), target.abs, caller).ok) return null;
+  if (datalessAmong(dirname(target.abs), [basename(target.abs)]).size) return null;
+  let raw;
+  try { raw = readFileSync(target.abs, "utf8"); } catch { return null; }
+  return block(target.rel, fileEntries(aiView(raw).text), max);
+}

package/lib/day-file.mjs

@@ -61,6 +61,13 @@ const pad = (n) => String(n).padStart(2, "0");
 export const localDate = (d) => `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
 export const localTime = (d) => `${pad(d.getHours())}:${pad(d.getMinutes())}`;
 
+// A conversation id a caller names so that separate evda_write calls continue one section (HQ-2823):
+// the prompt hook sends Claude Code's session_id. Short and opaque, letters, digits, `_` and `-`
+// only, because the writer names a state file after it. Checked here so the hook and evda_write
+// read one rule.
+export const CONVERSATION_MAX = 128;
+export const isConversationId = (v) => typeof v === "string" && v.length <= CONVERSATION_MAX && /^[A-Za-z0-9_-]+$/.test(v);
+
 export const contextLine = (context) => `*${CONTEXT_LABEL} ${String(context).trim().replace(/\*/g, "")}*`;
 
 // NAMED ENTRIES (HQ-2799). A write tool's answer names the existing entries the filed words bear on

package/lib/doctor.mjs

@@ -48,7 +48,7 @@
 
 import { checkoutFreshness } from "./checkout-freshness.mjs";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { join, relative, resolve, sep } from "node:path";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { readManifest, checkVersion, unknownKeys, unknownLayers, holderOf, holderProblems, KNOWN_LAYERS, SCHEMA_VERSION } from "./manifest.mjs";
 import { readGrants } from "./grants.mjs";
 import { readDevices } from "./devices.mjs";
@@ -77,7 +77,7 @@ import { FILING_MODES, filingOf } from "./day-file.mjs";
 import { correctionsTarget } from "./corrections.mjs";
 import { EVERY_CHAT_KEY } from "./every-chat.mjs";
 import { listSkills, SKILLS_REL } from "./skills.mjs";
-import { guardStatus } from "./connect.mjs";
+import { guardStatus, GUARD_DIR_REL, GUARD_REL } from "./connect.mjs";
 import { readmeCitations, missingHeadings, README_REL } from "./readme.mjs";
 
 // The dated sections of a person-profile that no observation covers (HQ-1397). An observation
@@ -322,12 +322,16 @@ export function doctor(dir, { out = console.log, via = "argument", depth = 0, ch
 
   // 5c. the read guard (HQ-1374), the other hook create-evda installs for a Claude owner (HQ-1377):
   // a PreToolUse hook in the record's own settings that stops a Claude Code session reading a noted
-  // entry. Reported present or missing, like the Stop hook above; a registered guard whose file is
-  // gone warns, because every read then runs a command that is not there.
+  // entry. A registered guard whose file is gone fails (HQ-2819): every read then runs a command
+  // that is not there, Claude Code lets the read through, and the owner was told it is guarded. The
+  // usual cause is an install that pointed into an npx cache or a checkout since removed.
   const guard = guardStatus(dir);
+  const posixRel = (root, abs) => { const r = relative(resolve(root), abs); return r && !r.startsWith("..") && !isAbsolute(r) ? r.split(sep).join("/") : abs; };
   if (guard.problem) warn(SETTINGS_REL, guard.problem);
-  else if (guard.registered && !guard.file) warn(SETTINGS_REL, `registers the read guard, but ${guard.target} is missing, so Claude Code cannot run it and a noted entry is not held back there. \`evda hook install\` restores it.`);
-  else if (guard.registered) ok(1, "read guard", `${SETTINGS_REL} runs ${guard.target ?? "the evda guard through npx"} before Read, Grep and shell reads`);
+  else if (guard.registered && !guard.file) fail(SETTINGS_REL, `registers the read guard, but ${guard.missing.join(" and ")} ${guard.missing.length === 1 ? "is" : "are"} missing, so Claude Code cannot run it and a noted entry is not held back there. \`evda hook install\` copies the guard into ${GUARD_DIR_REL}/ and replaces the entry.`);
+  else if (guard.registered && guard.count > 1) warn(SETTINGS_REL, `registers the read guard ${guard.count} times. \`evda hook install\` leaves one.`);
+  else if (guard.registered && !guard.current) warn(GUARD_REL, "or a file copied beside it differs from what this tooling ships. `evda hook install` updates them.");
+  else if (guard.registered) ok(1, "read guard", `${SETTINGS_REL} runs ${guard.target ? posixRel(dir, guard.target) : "the evda guard through npx"} before Read, Grep and shell reads`);
   else skip("read guard", `not installed. A Claude Code session here is not stopped before reading a just-noted entry (the MCP server still holds it back); \`evda hook install\` adds it to ${SETTINGS_REL}.`);
 
   // 6. record files

package/lib/mcp.mjs

@@ -26,6 +26,7 @@ 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 { correctionsForLayer, TAUGHT_HEADING } from "./corrections.mjs";
 import { listSkills, getSkill, writeSkill, noticeRepeat, SKILLS_REL } from "./skills.mjs";
 import { createSubrecord } from "./subrecord.mjs";
 import { FALSIFY } from "./mcp-auth.mjs";
@@ -296,16 +297,27 @@ export function coreBlock(r) {
   return [];
 }
 
-export function layerParts(evda, client = null) {
+// HQ-2818: the layer ends with what the owner taught the agent (lib/corrections.mjs), the newest
+// entries of the corrections file evda.json names, the same on every surface, counted in the chat
+// budget like the core. A record that keeps them in AGENTS.md's own section already serves them in
+// the owner text, so nothing is added unless a chat's budget listed that section by heading.
+export function layerParts(evda, client = null, caller = null) {
   const profile = clientProfile(client?.name);
+  const who = caller ?? callerFrom({ clientName: client?.name ?? null });
   const r = tools.operatingLayer(evda);
   const owner = forSurface(r.text, profile.surface);
   const head = [chatSection(evda, r.text, { app: profile.app }), dispatchSection(profile.surface), PRIVACY_SECTION].join("\n\n");
   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, profile.budget);
-  const body = [...core, fit.text].join("\n\n");
+  const fitWith = (extra) => (profile.surface === "terminal" ? { text: owner.text, listed: [] } : fitChat(owner.text, fixed + extra, profile.budget));
+  let taught = correctionsForLayer(evda, who, { agentsPath: r.path });
+  let fit = fitWith(taught ? taught.text.length + 2 : 0);
+  if (!taught && fit.listed.includes(TAUGHT_HEADING)) {
+    taught = correctionsForLayer(evda, who, { agentsPath: r.path, taughtListed: findSection(owner.text, TAUGHT_HEADING, profile.surface).text });
+    if (taught) fit = fitWith(taught.text.length + 2);
+  }
+  const body = [...core, fit.text, ...(taught ? [taught.text] : [])].join("\n\n");
   const max = profile.max;
   const pieces = packSections(body, max - PART_RESERVE - head.length, max - PART_RESERVE);
   const n = pieces.length;
@@ -316,7 +328,7 @@ export function layerParts(evda, client = null) {
     const end = i < n - 1 ? `\n\n(Part ${i + 1} of ${n} ends here. The layer continues: call evda_operating_layer with {"part": ${i + 2}} now, before answering.)` : "";
     return `${top}${p}${end}`;
   });
-  return { path: r.path, core: r.core?.path ?? null, parts, chars, surface: profile.surface, left: owner.left, listed: fit.listed };
+  return { path: r.path, core: r.core?.path ?? null, parts, chars, surface: profile.surface, left: owner.left, listed: fit.listed, corrections: taught ? { path: taught.path, served: taught.served, total: taught.total } : null };
 }
 
 // Split text into pieces of at most `max` characters (the first at most `first`), cutting where a
@@ -342,6 +354,8 @@ export function packSections(text, first, max) {
 }
 
 const str = (description) => ({ type: "string", description });
+// evda_write's and evda_write_agent_log's `conversation` (HQ-2823), in one set of words for both.
+const CONVERSATION_ARG = str("Leave this out in a chat: the chat is already the conversation. A hook or relay that sends each message as a separate call (a new process each time) passes the same short id on every call (letters, digits, _ and -, at most 128 characters, e.g. Claude Code's session_id), so those calls continue one section under one heading instead of opening a new one each.");
 
 // summarize() already names the command for the two statuses that ask the owner to run one. Over
 // stdio the owner may have no shell in front of them at all (the Claude desktop app), and `evda
@@ -628,9 +642,9 @@ export const TOOLS = [
         if (!Number.isInteger(part) || part < 1 || part > s.parts.length) throw tools.refuse(`evda_operating_layer "part" is a whole number from 1 to ${s.parts.length}; this section has ${s.parts.length === 1 ? "one part" : `${s.parts.length} parts`}.`, "BAD_ARGUMENT");
         return { text: s.parts[part - 1], data: { path: s.path, section: s.heading, part, parts: s.parts.length } };
       }
-      const l = layerParts(evda, ctx.client);
+      const l = layerParts(evda, ctx.client, ctx.caller);
       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 };
+      const data = { path: l.path, core: l.core, part, parts: l.parts.length, chars: l.chars, listed: l.listed, corrections: l.corrections };
       if (!opening) return { text: l.parts[part - 1], data };
       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 } };
@@ -687,7 +701,7 @@ export const TOOLS = [
     name: "evda_write",
     title: "File the owner's words",
     description: WRITE_DESCRIPTION.everything,
-    inputSchema: { type: "object", properties: { words: str("The owner's words, verbatim: filler, hedges and typos intact. Never a summary."), context: str("One line, yours, on what the conversation was about. Written above their words and labeled as not theirs. Never their words.") }, required: ["words"], additionalProperties: false },
+    inputSchema: { type: "object", properties: { words: str("The owner's words, verbatim: filler, hedges and typos intact. Never a summary."), context: str("One line, yours, on what the conversation was about. Written above their words and labeled as not theirs. Never their words."), conversation: CONVERSATION_ARG }, required: ["words"], additionalProperties: false },
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
     run: async (evda, args, ctx) => {
       const dup = sameAsFiled(ctx.session, args?.words);
@@ -725,7 +739,7 @@ export const TOOLS = [
     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. 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 },
+    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."), conversation: CONVERSATION_ARG }, 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 });

package/lib/plugin-hook.mjs

@@ -82,7 +82,9 @@ export function handle(mode, baked, input, env = process.env) {
       const settings = JSON.parse(readFileSync(join(root, ".claude", "settings.json"), "utf8"));
       const cmd = (settings?.hooks?.PreToolUse ?? []).flatMap((m) => (m?.hooks ?? []).map((h) => h?.command)).find((c) => typeof c === "string" && GUARD_MARK.test(c));
       if (!cmd) return none;
-      const r = spawnSync(cmd, { shell: true, input, encoding: "utf8", timeout: 25000 });
+      // The record's settings name the guard under $CLAUDE_PROJECT_DIR (HQ-2819), and a Cowork task's
+      // project is not the record, so it is set to the record for this one command.
+      const r = spawnSync(cmd, { shell: true, input, encoding: "utf8", timeout: 25000, env: { ...process.env, CLAUDE_PROJECT_DIR: root } });
       return { stdout: r.stdout ?? "", stderr: r.stderr ?? "", code: r.status === 2 ? 2 : 0 };
     }
     return none;

package/lib/prompt-hook.mjs

@@ -48,7 +48,7 @@ import { dirname, join, relative } from "node:path";
 import { homedir, hostname, tmpdir } from "node:os";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { dayRole, findRecord, filingOf, appendToDay, localDate } from "./day-file.mjs";
+import { dayRole, findRecord, filingOf, appendToDay, localDate, isConversationId } from "./day-file.mjs";
 import { secretShape } from "./secret-shape.mjs";
 
 export const PROMPT_HOOK_NAME = "evda-file-prompt.mjs";
@@ -67,14 +67,16 @@ export function promptOutboxDir(env = process.env) {
 const realOr = (p) => { try { return realpathSync(p); } catch { return p; } };
 
 // Save one message for the writer: a new file per message, never rewritten, in this machine's outbox.
-export function queuePrompt(root, { words, context, now = new Date(), env = process.env }) {
+// `conversation` is the Claude Code session it was said in, kept with it so a message that waited
+// still continues its conversation's section when it is sent.
+export function queuePrompt(root, { words, context, conversation = null, now = new Date(), env = process.env }) {
   const dir = promptOutboxDir(env);
   mkdirSync(dir, { recursive: true });
   const at = now.toISOString();
   const stamp = at.replace(/[-:.]/g, "");
   let file = join(dir, `${stamp}-${process.pid}.json`);
   for (let n = 2; existsSync(file); n++) file = join(dir, `${stamp}-${process.pid}-${n}.json`);
-  writeFileSync(file, JSON.stringify({ tool: "evda_write", record: realOr(root), words, context, at, host: hostname().split(".")[0] || "host" }, null, 1) + "\n", { flag: "wx" });
+  writeFileSync(file, JSON.stringify({ tool: "evda_write", record: realOr(root), words, context, ...(conversation ? { conversation } : {}), at, host: hostname().split(".")[0] || "host" }, null, 1) + "\n", { flag: "wx" });
   return file;
 }
 
@@ -104,7 +106,7 @@ export function drainPromptOutbox(root, { env = process.env, budgetMs = Number(e
     let entry;
     try { entry = JSON.parse(readFileSync(claim, "utf8")); } catch { renameSync(claim, abs); continue; }
     const left = deadline - Date.now();
-    const args = { words: entry.words, ...(entry.context ? { context: entry.context } : {}) };
+    const args = { words: entry.words, ...(entry.context ? { context: entry.context } : {}), ...(isConversationId(entry.conversation) ? { conversation: entry.conversation } : {}) };
     const r = left > 200 ? spawnSync(cmd, { shell: true, input: JSON.stringify(args), encoding: "utf8", timeout: left, env }) : { status: null, error: { code: "ETIMEDOUT" } };
     if (r.status === 0) { unlinkSync(claim); out.sent.push(abs); continue; }
     try { renameSync(claim, abs); } catch { /* kept as a claim; the stale rule puts it back */ }
@@ -118,12 +120,20 @@ export function drainPromptOutbox(root, { env = process.env, budgetMs = Number(e
 const timeOf = (d) => `${localDate(d)} ${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
 
 // The non-writer path: queue, send, and say what happened. Never touches the day file.
-function viaWriter(root, prompt, now, env) {
+//
+// Every send is a separate evda_write on the writer, so each names its conversation, Claude Code's
+// session_id, and the writer continues that conversation's section (HQ-2823, lib/conversation.mjs).
+// The context line goes with every send: the writer files it once, on the conversation's first
+// write, and again only if that section is gone (edited away, or its state older than two days),
+// so a continuing conversation never opens a bare heading. A session_id that is not an id's shape
+// is not sent, and that message opens its own section, as every message did before.
+function viaWriter(root, prompt, now, env, sid) {
   const writer = env.EVDA_DAY_WRITER.trim();
   if (!(env[DAY_WRITER_SEND_ENV] ?? "").trim()) {
     return `evda: this machine does not write the daily file (EVDA_DAY_WRITER is ${writer}) and has no ${DAY_WRITER_SEND_ENV} to reach it, so the owner's message above is NOT filed yet. File it verbatim with evda_write this turn.`;
   }
-  const file = queuePrompt(root, { words: prompt, context: `Claude Code on ${hostname().split(".")[0]}, said ${timeOf(now)}`, now, env });
+  const conversation = isConversationId(sid) ? sid : null;
+  const file = queuePrompt(root, { words: prompt, context: `Claude Code on ${hostname().split(".")[0]}, said ${timeOf(now)}`, conversation, now, env });
   const r = drainPromptOutbox(root, { env });
   if (r.sent.includes(file)) {
     const more = r.sent.length > 1 ? ` (with ${r.sent.length - 1} message(s) queued earlier)` : "";
@@ -147,10 +157,23 @@ function markFiled(sid, now) {
   writeFileSync(sf, JSON.stringify({ ...session, filedAt: now.toISOString() }) + "\n");
 }
 
+// Claude Code delivers some of its own text through UserPromptSubmit: a background task's
+// completion arrives as a <task-notification> block, and context it adds rides in <system-reminder>
+// blocks. Neither is the owner's, and filing them put whole subagent reports into an owner's day as
+// his words (HQ-2823). Strip those blocks; what is left is what the owner typed, or nothing.
+export const HARNESS_BLOCKS = ["task-notification", "system-reminder"];
+export function ownerWords(prompt) {
+  const text = String(prompt);
+  let out = text;
+  for (const tag of HARNESS_BLOCKS) out = out.replace(new RegExp(`<${tag}>[\\s\\S]*?</${tag}>`, "g"), "");
+  if (out === text) return text; // nothing of the harness's: the words stay byte for byte
+  return out.trim() === "" ? "" : out.replace(/^\s*\n/, "").replace(/\n\s*$/, "");
+}
+
 // One UserPromptSubmit event in, the hook's stdout out ("" for nothing to say). Never throws.
 export function run(payload, { now = new Date(), env = process.env } = {}) {
   try {
-    const prompt = typeof payload?.prompt === "string" ? payload.prompt : "";
+    const prompt = ownerWords(typeof payload?.prompt === "string" ? payload.prompt : "");
     if (!prompt.trim() || /^\s*\//.test(prompt)) return "";
     const here = dirname(fileURLToPath(import.meta.url));
     const root = findRecord(payload.cwd || process.cwd()) ?? findRecord(here);
@@ -162,7 +185,7 @@ export function run(payload, { now = new Date(), env = process.env } = {}) {
     const shape = prompt.split("\n").map(secretShape).find(Boolean);
     if (shape) return `evda: this message was not filed, because it holds ${shape}. Keep that in a password manager; file the rest of what they said with evda_write if it is worth keeping.`;
     if ((env.EVDA_DAY_WRITER ?? "").trim()) {
-      const said = viaWriter(root, prompt, now, env);
+      const said = viaWriter(root, prompt, now, env, payload.session_id);
       if ((env[DAY_WRITER_SEND_ENV] ?? "").trim()) markFiled(payload.session_id, now); // sent or queued to send
       return said;
     }

package/lib/tools.mjs

@@ -41,7 +41,8 @@ import { secretShape } from "./references.mjs";
 import { doctor } from "./doctor.mjs";
 import { readContext, mayRead, heldBack, callerFrom, aiView, note as writeNote, releaseNote, SEALED_WHY, isSealedFile, isNotedFile } from "./readers.mjs";
 import { EvdaError } from "./errors.mjs";
-import { dayRole, appendToDay, setPointerLine, CONTEXT_LABEL, localDate, localTime } from "./day-file.mjs";
+import { dayRole, appendToDay, setPointerLine, CONTEXT_LABEL, localDate, localTime, isConversationId, CONVERSATION_MAX } from "./day-file.mjs";
+import { loadConversation, saveConversation } from "./conversation.mjs";
 import { writeMessage, unseenReplies, agentName } from "./messages.mjs";
 import { acknowledge as writeAcknowledgement, readAcknowledged, acknowledgementsFor } from "./acknowledge.mjs";
 import { openEvda, holderOf } from "./manifest.mjs";
@@ -309,8 +310,13 @@ export const CONTEXT_MAX = 240;
 // another tool's own name when it reuses this same append-only logic against a different day
 // file (evda_write_agent_log, against Iris's own sub-record). The behavior is identical either
 // way; only what a refusal calls itself changes.
+//
+// `conversation` (HQ-2823) is an id a hook or relay names so that separate calls, each in a fresh
+// process with no `session` of its own, continue one section: its section state is loaded from and
+// saved to lib/conversation.mjs, outside the record. Given, it is the conversation, in place of
+// `session`. A chat app holds its session already and never sends it.
 export function write(evda, args = {}, { now = new Date(), session = null, toolName = "evda_write" } = {}) {
-  onlyKeys(toolName, args, ["words", "context"], "It appends to today's daily file and nothing else: it takes no path, and it never replaces or edits what is already written.");
+  onlyKeys(toolName, args, ["words", "context", "conversation"], "It appends to today's daily file and nothing else: it takes no path, and it never replaces or edits what is already written.");
   const words = text(args.words, "words", toolName);
   refuseSecrets(words, toolName);
   let context = null;
@@ -321,6 +327,10 @@ export function write(evda, args = {}, { now = new Date(), session = null, toolN
     refuseSecrets(args.context, toolName);
     context = args.context.trim();
   }
+  const conversation = args.conversation;
+  if (conversation !== undefined && !isConversationId(conversation)) {
+    throw refuse(`${toolName} "conversation" is a short id a hook or relay sends so separate calls continue one section: letters, digits, "_" and "-" only, at most ${CONVERSATION_MAX} characters. A chat app leaves it out.`, "CONVERSATION");
+  }
   const abs = join(evda.dir, todayPath(evda, { now }));
   mkdirSync(dirname(abs), { recursive: true });
   // The owner's day only: evda_write, and the tools that file the owner's message along with them.
@@ -328,11 +338,15 @@ export function write(evda, args = {}, { now = new Date(), session = null, toolN
   if (toolName !== "evda_write_agent_log") {
     const held = dayWriteHeld(abs);
     if (held !== null) {
-      const q = queueToOutbox(abs, { now, words, context });
+      const q = queueToOutbox(abs, { now, words, context, conversation });
       return { path: rel(evda, q), bytes: Buffer.byteLength(words), queued: true, held };
     }
   }
-  const w = appendToDay(abs, { now, words, context, session });
+  const conv = conversation === undefined ? null : loadConversation(conversation);
+  const w = appendToDay(abs, { now, words, context, session: conv ?? session });
+  // The words are in the day by now: a save that fails costs the next call a new heading, never a
+  // refusal that would have the caller send the same words again.
+  if (conv) { try { saveConversation(conversation, conv); } catch { /* see above */ } }
   return { path: rel(evda, abs), bytes: Buffer.byteLength(words), section: w.opened ? "opened" : "continued" };
 }
 
@@ -354,10 +368,10 @@ function dayWriteHeld(abs) {
 }
 
 // Queue held words where the writer files them later (HQ-2596): one new JSON file per write in the
-// daily folder's .outbox/, {tool, words, context, at, host}, named `<UTC timestamp>-<host>-evda_write.json`
+// daily folder's .outbox/, {tool, words, context, at, host} and the caller's conversation when it named one, named `<UTC timestamp>-<host>-evda_write.json`
 // (the shape the day-writer guard's refusal names, lib/day-writer.mjs OUTBOX_DIR). One file per write,
 // so no two writers ever share one and no sync can drop either. Returns the file's absolute path.
-function queueToOutbox(abs, { now, words, context }) {
+function queueToOutbox(abs, { now, words, context, conversation }) {
   const box = join(dirname(abs), ".outbox");
   mkdirSync(box, { recursive: true });
   const at = now.toISOString().replace(/\.\d{3}Z$/, "Z");
@@ -365,7 +379,7 @@ function queueToOutbox(abs, { now, words, context }) {
   const stamp = at.replace(/[-:]/g, "").replace(/^(\d{8})T/, (_, d) => `${d.slice(0, 4)}-${d.slice(4, 6)}-${d.slice(6)}T`);
   let file = join(box, `${stamp}-${host}-evda_write.json`);
   for (let n = 2; existsSync(file); n++) file = join(box, `${stamp}-${host}-evda_write-${n}.json`);
-  writeFileSync(file, JSON.stringify({ tool: "evda_write", words: String(words), context: context ?? "", at, host }, null, 1), { flag: "wx" });
+  writeFileSync(file, JSON.stringify({ tool: "evda_write", words: String(words), context: context ?? "", at, host, ...(conversation === undefined ? {} : { conversation }) }, null, 1), { flag: "wx" });
   return file;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-evda",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "type": "module",
   "description": "The person layer over the substrate: scaffold and operate an EVDA, a directory that knows what it is. Plain files are the truth, the tooling is optional, and there are no runtime dependencies.",
   "bin": {