create-evda 0.1.9 → 0.1.10

package/lib/day-file.mjs

@@ -6,9 +6,10 @@
 // local time) with its one line of context; every later write in the same conversation appends
 // under it, as a new paragraph, with no heading. A conversation is whatever the caller passes as
 // `session`: one MCP session (a stdio process, or one Mcp-Session-Id over HTTP), or one Claude Code
-// session id in the prompt hook. When the file changed since this conversation last wrote to it
-// (another conversation wrote a section, or someone edited it by hand), the next write opens a new
-// heading, so words never land under a heading that is not theirs.
+// session id in the prompt hook. When another conversation wrote a section below this one since,
+// the next write still goes into this conversation's own section, above theirs (HQ-2330), so words
+// never land under a heading that is not theirs and one conversation stays one section. Only a hand
+// edit of the section itself makes the next write open a new heading.
 //
 // FILING. evda.json `filing` is the owner's answer to the one setup question: "everything" (file
 // every message they send, without being asked) or "asked" (only when they ask). Absent means they
@@ -22,7 +23,7 @@
 // EVDA_CHAT_FALSIFY=heading-per-write opens a new heading on every write, for the test that shows
 // one conversation is one section.
 
-import { appendFileSync, closeSync, existsSync, openSync, readFileSync, statSync, unlinkSync, writeSync } from "node:fs";
+import { appendFileSync, closeSync, existsSync, openSync, readFileSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 
 export const FILING_MODES = ["everything", "asked"];
@@ -62,6 +63,48 @@ export const localTime = (d) => `${pad(d.getHours())}:${pad(d.getMinutes())}`;
 
 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
+// (lib/touches.mjs, HQ-2631), and a conversation named some and added to none of them is asked once.
+// The MCP server keeps what it named per chat; the Stop hook reads the same lines back out of the
+// Claude Code transcript. Both build and parse them here, so the line one writes is the line the
+// other reads, and nothing is stored in the owner's files: the transcript and the chat are the state.
+export const RELATED_LEAD = "These existing entries bear on what you just filed: ";
+export const TICKETS_LEAD = "These open tickets on the board bear on it: ";
+export const ENTRIES_ASK_LEAD = "This conversation was pointed at existing entries and added to none of them:";
+
+export const relatedLine = (related) => `${RELATED_LEAD}${related.map((r) => `${r.path} (named as "${r.name}")`).join("; ")}.`;
+
+export const ticketsLine = (tickets) => `${TICKETS_LEAD}${tickets.map((k) => `${k.id} "${k.title}" (named as "${k.named}")`).join("; ")}.`;
+
+// The open tickets a tool result's text names (HQ-2798's line), as ["HQ-<n>", ...].
+export function ticketsNamedIn(text) {
+  const out = [];
+  for (const line of String(text ?? "").split("\n")) {
+    if (!line.startsWith(TICKETS_LEAD)) continue;
+    for (const m of line.slice(TICKETS_LEAD.length).matchAll(/(?:^|; )(HQ-\d+) "/g)) if (!out.includes(m[1])) out.push(m[1]);
+  }
+  return out;
+}
+
+// The entries a tool result's text names, as [{ path, name }], from its RELATED_LEAD line.
+export function namedIn(text) {
+  const out = [];
+  for (const line of String(text ?? "").split("\n")) {
+    if (!line.startsWith(RELATED_LEAD)) continue;
+    const body = line.slice(RELATED_LEAD.length).replace(/\.$/, "");
+    for (const m of body.matchAll(/(?:^|; )(.+?) \(named as "([^"]*)"\)/g)) out.push({ path: m[1], name: m[2] });
+  }
+  return out;
+}
+
+// Whether a text already carries the ask, so neither surface asks a second time.
+export const askedIn = (text) => String(text ?? "").includes(ENTRIES_ASK_LEAD);
+
+// The ask, naming the entries and tickets. `how` says how this surface adds to an entry.
+export function entriesAsk(paths, how = "evda_append; a person's page with evda_record_person_note", tickets = []) {
+  return `${ENTRIES_ASK_LEAD} ${[...paths, ...tickets].join(", ")}. If what the owner said adds something to one of them, add a dated section to it now (${how})${tickets.length ? ", or update the ticket on the board" : ""}. If nothing new applies, adding nothing is fine. This is asked once.`;
+}
+
 // The bytes one write appends to a day file whose current text is `current` (null when it does not
 // exist yet). `continuing` is true when this conversation's section is the last thing in the file.
 // Returns { text, opened }.
@@ -125,18 +168,84 @@ function withDayLock(fn) {
 }
 
 // Append `words` to the day file at `abs`. `session` is the conversation's mutable state ({} to
-// start one, null for a write that belongs to no conversation, which always opens a heading); it
-// remembers which file this conversation's section is in and how long that file was after its last
-// write. Returns { opened, bytes }.
+// start one, null for a write that belongs to no conversation, which always opens a heading).
+//
+// HQ-2330: the conversation keeps its section, one per file, in `session.sections[abs]`: the
+// section's exact text as this conversation last wrote it (`tail`, from its heading to its last
+// words) and whether it carries a context line. A later write finds that text in the file and goes
+// straight after it: at the end of the file when nothing came after (a plain append, as before),
+// or above whatever another writer added below it since (a read-modify-write under the same lock).
+// Keyed by file, so the agent log and the owner's day each keep their own section in one chat
+// (measured 2026-10-07: a Claude Code session's evda_write_agent_log between two evda_writes left
+// the next write a bare `## 20:41`, and the agent log a bare heading per entry). When the section's
+// text is no longer in the file (edited by hand), the write opens a new heading, and that heading
+// repeats the conversation's context line, so a continuing conversation never has a bare heading.
+// Returns { opened, bytes, inserted }.
 export function appendToDay(abs, { now = new Date(), words, context = null, session = null }) {
   return withDayLock(() => {
     const exists = existsSync(abs);
     const current = exists ? readFileSync(abs, "utf8") : null;
-    const s = session?.section;
-    const continuing = Boolean(s && exists && s.abs === abs && statSync(abs).size === s.size);
-    const w = sectionBytes({ current, date: localDate(now), time: localTime(now), words, context, continuing, contextWritten: Boolean(s?.context) });
+    const mine = session ? sectionOf(session, abs) : null;
+    const at = mine && current !== null && !falsified("heading-per-write") ? current.lastIndexOf(mine.tail) : -1;
+    if (at >= 0) {
+      const body = String(words).replace(/\n+$/, "");
+      const ctx = context && !mine.context ? `${contextLine(context)}\n\n` : "";
+      const add = `\n${ctx}${body}\n`;
+      const end = at + mine.tail.length;
+      if (end === current.length) appendFileSync(abs, add);
+      else writeFileSync(abs, current.slice(0, end) + add + current.slice(end));
+      session.sections[abs] = { tail: mine.tail + add, context: mine.context || Boolean(ctx), line: mine.line ?? (context ? String(context).trim() : null) };
+      return { opened: false, bytes: Buffer.byteLength(add), inserted: end !== current.length };
+    }
+    // A new section. A conversation that already had one here and lost it keeps its context line.
+    const line = context ?? mine?.line ?? null;
+    const w = sectionBytes({ current, date: localDate(now), time: localTime(now), words, context: line, continuing: false });
     appendFileSync(abs, w.text);
-    if (session) session.section = { abs, size: statSync(abs).size, context: Boolean(context) || (continuing && Boolean(s?.context)) };
-    return { opened: w.opened, bytes: Buffer.byteLength(w.text) };
+    if (session) {
+      const start = w.text.indexOf("\n## ");
+      session.sections ??= {};
+      session.sections[abs] = { tail: w.text.slice(start + 1), context: Boolean(line), line: line === null ? null : String(line).trim() };
+    }
+    return { opened: true, bytes: Buffer.byteLength(w.text), inserted: false };
+  });
+}
+
+// This conversation's section in the file at `abs`, or null. A session saved before HQ-2330 kept
+// one `section` by size, not text; it is read as no section, so its next write opens a heading.
+function sectionOf(session, abs) {
+  const s = session.sections?.[abs];
+  return s && typeof s.tail === "string" && s.tail ? s : null;
+}
+
+// The one pointer line under `heading` in the day file at `abs` (HQ-2306): the line in the owner's
+// day that points at an agent's own log for that day. Exactly one line starting with `prefix` lives
+// in that section; this replaces it in place, inserts it under the heading, appends the heading
+// after everything else, or creates the day, and touches no other byte. Under the same lock as
+// appendToDay, because this is a read-modify-write and a stale read would drop an append.
+// Returns "created", "added", "inserted" or "refreshed".
+export function setPointerLine(abs, { date, heading, prefix, line }) {
+  return withDayLock(() => {
+    const existing = existsSync(abs) ? readFileSync(abs, "utf8") : "";
+    if (existing === "") {
+      writeFileSync(abs, `# ${date}\n\n${heading}\n\n${line}\n`);
+      return "created";
+    }
+    const lines = existing.split("\n");
+    const at = lines.findIndex((l) => l.trim() === heading);
+    if (at === -1) {
+      appendFileSync(abs, `${existing.endsWith("\n") ? "" : "\n"}\n${heading}\n\n${line}\n`);
+      return "added";
+    }
+    let end = lines.length;
+    for (let i = at + 1; i < lines.length; i++) if (/^#{1,6} /.test(lines[i])) { end = i; break; }
+    const idx = lines.slice(at + 1, end).findIndex((l) => l.startsWith(prefix));
+    if (idx === -1) {
+      lines.splice(at + 1, 0, "", line);
+      writeFileSync(abs, lines.join("\n"));
+      return "inserted";
+    }
+    lines[at + 1 + idx] = line;
+    writeFileSync(abs, lines.join("\n"));
+    return "refreshed";
   });
 }

package/lib/day-writer.mjs

@@ -66,8 +66,15 @@ export function isDayFile(abs) {
   return real(dirname(abs)) === day;
 }
 
+// HQ-2596: where words wait when the writer cannot be reached. One JSON file per write in the daily
+// folder's `.outbox/`, so each file has one writer and no sync can drop it; the writer files them,
+// oldest first, once its own copy of the day has synced. A file in that folder is not a day file, so
+// this guard allows writing it.
+export const OUTBOX_DIR = ".outbox";
+
 function sentence(writer, file) {
-  return `EVÐA: ${basename(file)} is the daily file, and this machine does not write it. ${DAY_WRITER_ENV} names the machine that does (${writer}). Two machines writing one daily file through a synced folder lose one of the writes with no conflict copy. Append the words with the evda MCP tool evda_write, which that machine serves. If evda_write is not connected in this session, tell the owner in one plain sentence that the words were not filed and why, and do not write the file here.`;
+  const outbox = `${join(dirname(file), OUTBOX_DIR)}/`;
+  return `EVÐA: ${basename(file)} is the daily file, and this machine does not write it. ${DAY_WRITER_ENV} names the machine that does (${writer}). Two machines writing one daily file through a synced folder lose one of the writes with no conflict copy. Append the words with the evda MCP tool evda_write, which that machine serves. If evda_write is not connected or that machine cannot be reached, queue the words in the outbox instead: write one new file per message to ${outbox}<UTC timestamp>-<host>-evda_write.json holding {tool, words, context, at, host} (tool "evda_write", words verbatim, at in UTC ISO), and the writer files them into the day when it is back. Tell the owner the words are queued, not filed, and do not write the daily file here.`;
 }
 
 // The decision for one PreToolUse input. { decision: "allow" } or { decision: "deny", reason }.

package/lib/doctor.mjs

@@ -69,9 +69,11 @@ import { folderManifests, folderFor, viewNamedIn, FOLDER_MANIFEST } from "./fold
 import { referencesIn } from "./references.mjs";
 import { KIND_FOR_TYPE, PERSON_KINDS, entryFromFile, readEntry } from "./kinds.mjs";
 import { datedHeadings } from "./migrate-people.mjs";
+import { personFolderProblems, README_NAME } from "./person-folders.mjs";
 import { EvdaError } from "./errors.mjs";
 import { hookStatus, promptHookStatus, HOOK_REL, PROMPT_HOOK_REL, SETTINGS_REL } from "./hooks.mjs";
 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";
@@ -237,7 +239,12 @@ export function doctor(dir, { out = console.log, via = "argument", depth = 0 } =
         fail(rel, e.message);
       }
       if (fence === null) warn(rel, "has no evda:generated fence. The owner has taken the whole file; `evda upgrade` has nothing it owns to replace.");
-      if (!/## What I have been taught/.test(agents)) warn(rel, 'has no "## What I have been taught" section, so a correction has nowhere to land.');
+      // HQ-2325: a record that keeps its corrections in their own file names it in evda.json, and
+      // then the heading is not where they land, so its absence is not a warning.
+      const corrections = correctionsTarget({ dir, manifest });
+      if (corrections?.problem) warn("evda.json", `${corrections.problem} evda_record_correction refuses until it does.`);
+      else if (corrections) ok(1, "corrections", `evda.json names ${corrections.rel}: a correction lands there as a dated section`);
+      else if (!/## What I have been taught/.test(agents)) warn(rel, 'has no "## What I have been taught" section, and evda.json names no "corrections" file, so a correction has nowhere to land.');
     }
     // Claude Code reads CLAUDE.md and nothing else. If the operating layer is elsewhere, CLAUDE.md
     // has to import it or a Claude Code session here starts with no instructions.
@@ -673,10 +680,21 @@ export function doctor(dir, { out = console.log, via = "argument", depth = 0 } =
           if (name === FOLDER_MANIFEST) continue;
           const rel = relative(dir, p);
           const read = entryFromFile(name, readFileSync(p, "utf8"));
-          if (read === null) continue;
+          // In a person folder every file directly inside is a person's profile (HQ-2024), so one
+          // with no kind is a profile doctor would otherwise never read, and fails. Its README, its
+          // manifest and its declared views are not people; Processing/ sits beside the folder.
+          const unread = want === "person-profile" && p.slice(0, p.lastIndexOf(sep)) === f.dir && name !== README_NAME;
+          if (read === null) {
+            if (unread && /\.md$/i.test(name)) fail(rel, `has no person-profile frontmatter, so doctor never reads it. ${where} declares type person: every file in it opens with kind: person-profile (scripts/migrate-people.mjs adds it).`);
+            continue;
+          }
           if (read.error) { fail(rel, `${read.error} ${where} holds ${want} entries.`); continue; }
           const kind = read.raw?.kind;
-          if (kind === undefined) { warn(rel, `has no "kind", so it is not read as a ${want}. ${where} declares type ${f.type}.`); continue; }
+          if (kind === undefined) {
+            if (unread) fail(rel, `has no "kind", so doctor never reads it as a person-profile. ${where} declares type person.`);
+            else warn(rel, `has no "kind", so it is not read as a ${want}. ${where} declares type ${f.type}.`);
+            continue;
+          }
           entries += 1;
           if (kind !== want) { fail(rel, `is a ${kind}, and ${where} declares type ${f.type}, whose entries are ${want}. Move it, or say what the folder holds.`); continue; }
           counts[want] = (counts[want] ?? 0) + 1;
@@ -695,6 +713,17 @@ export function doctor(dir, { out = console.log, via = "argument", depth = 0 } =
           }
         }
       }
+      // Person folders (HQ-2024, lib/person-folders.mjs): one file per person, named for the
+      // person, no subfolder, no lone parenthetical, no redirect stub. Read across every person
+      // folder at once, because two people who share a name can live in two folders.
+      const people = typed.filter((f) => f.type === "person");
+      if (people.length) {
+        const skipPaths = new Set(people.flatMap((f) => [join(f.dir, FOLDER_MANIFEST), ...f.views.map((v) => resolve(dir, v.path))]));
+        const layout = personFolderProblems(people.map((f) => f.dir), { skip: skipPaths });
+        for (const p of layout.problems) fail(relative(dir, p.path), p.message);
+        if (layout.files === 0) skip("person folder layout", `${people.length} person folder(s) hold no person files yet`);
+        else ok(layout.files, "person files", `across ${people.length} person folder(s): one file each, no subfolder, no lone parenthetical, no redirect stub`);
+      }
       if (entries === 0) skip("typed entries", `${typed.length} typed folder(s) hold no entry files yet`);
       else ok(entries, "typed entries", `across ${typed.length} folder(s): ${PERSON_KINDS.filter((k) => counts[k]).map((k) => `${counts[k]} ${k}`).join(", ") || "none of the declared kind"}`);
     }

package/lib/every-chat.mjs

@@ -12,6 +12,8 @@
 // here, so no surface can carry a different copy. No node: imports, because lib/clients.mjs is
 // rendered in the EVDA app's webview and reads this file.
 
+import { appLike } from "./connecting-apps.mjs";
+
 export const EVERY_CHAT_KEY = "every_chat";
 
 // Bumped when the line's meaning changes. An owner who set an older version is asked once more,
@@ -66,18 +68,12 @@ export const CHAT_APPS = {
 };
 export const GENERIC_WHERE = "Add it to your app's every-chat instructions: the setting that applies to all of your conversations, not just this one.";
 
-// Which app is calling, from initialize's clientInfo.name. Coding agents (Claude Code, Codex,
-// Cursor and the like) are left out, because their every-session file is AGENTS.md or CLAUDE.md,
-// which create-evda already writes into the record. Matched by pattern: the names claude.ai and
-// ChatGPT send are not yet measured (HQ-2207 measures them), and a name that matches nothing is
-// "other", which is asked with GENERIC_WHERE rather than skipped, so a new app still gets the line.
-const CODING = /claude[-_ ]?code|codex|cursor|copilot|vscode|windsurf|zed|opencode|cline|aider|gemini[-_ ]?cli|goose|mcp-inspector|inspector/i;
+// Which chat app is calling, from initialize's clientInfo.name: the every-chat key of the first row
+// in lib/connecting-apps.mjs (HQ-2218) whose pattern matches it. A coding agent's row has none
+// (null), and a name no row matches is "other", asked with GENERIC_WHERE rather than skipped.
 export function chatAppOf(clientName) {
-  const n = String(clientName ?? "").trim();
-  if (CODING.test(n)) return null;
-  if (/claude|anthropic/i.test(n)) return "claude";
-  if (/openai|chatgpt/i.test(n)) return "chatgpt";
-  return "other";
+  const row = appLike(clientName);
+  return row ? row.chat : "other";
 }
 
 // What evda.json says for one app: { state: "set" | "declined", form, version, date } or null.