create-evda 0.1.7 → 0.1.9

package/CHANGELOG.md

@@ -4,6 +4,51 @@ Plain-English notes on how Iris behaves differently after each version. Not a co
 
 ## Unreleased
 
+When two of your machines share one record through iCloud, one of them can be the only one that
+writes the daily note. Set EVDA_DAY_WRITER on every other machine and add hooks/evda-day-writer-guard.mjs
+to that machine's own Claude Code settings: an agent there that tries to write the note directly is
+stopped and told to file through evda_write on the writing machine, because two machines writing the
+same note within seconds lose one of the writes with no conflict copy.
+
+The first time you talk to your EVÐA from a chat app (Claude, ChatGPT, or any other), Iris gives
+you one line to add to that app's every-chat instructions, and says where that setting is. With it
+there, every chat starts as Iris, even one that never opens your record. Tell Iris it is set, or
+that you don't want it, and that app never asks again; a second app asks once for itself. If you
+file only when you ask, the line loads Iris and asks for nothing more. `create-evda` and `evda
+connect` print the same line.
+
+The EVÐA app is one sidebar and the page you are reading. Today's Journal is first, there even
+before you have written today, and what you type at the end of it is added to today's note,
+verbatim, the way your AI's evda_write does. Below it, Journal, Captures, People and your project,
+area and knowledge folders are pinned from your mapping, then Instructions (CLAUDE.md, AGENTS.md,
+evda.json and any file the agents block is written into), then every folder of the record. Devices,
+Connect your AI and Switch EVÐA sit quietly at the foot. A file's circle shows only when it is not
+your record's usual one, and markdown reads formatted. Entries you noted or sealed, and parts you
+set so no AI reads, stay closed. Tooling (dot-files, lockfiles, scripts, licenses, backups, empty
+files) is left out, with one line per folder counting it. The window drags by its top edge. Large
+files open whole: `evda browse` and `evda capture` wait for their answer to reach the app before
+exiting, where before a file past 64 KB arrived cut off.
+
+Your phone can join your EVÐA. `evda pair` on the computer your record is on shows a one-time code
+and a QR link; it works once, for 10 minutes, and the phone gets only the parts you name (the
+journal by default). `evda sync` adds the phone once it has used the code, takes in what it wrote,
+and sends what changed; a note written on the phone lands under the day, in your words. `evda
+devices` lists what is paired and `evda remove <device>` removes one: it adds nothing more and
+receives nothing new. You can also ask your AI to do all of it (`evda_pair`, `evda_devices`, `evda_sync_status`,
+`evda_remove_device`): it shows a QR code to scan, adds the phone on its own once it scans, says
+when each device was last heard from and what is still on its way to it, and removes a device only
+after you say yes to what removing does. A phone paired this way pairs to the computer the AI's
+EVÐA server runs on, and the answer names that computer. A second computer of yours (Hestia) speaks
+as its own device and never as the laptop: until a grant makes it owner of a part it refuses to
+pair, and once it owns one it pairs a phone to itself. Pairing goes
+through a relay that cannot read what it carries, and needs Node 22.13 or newer; everything else
+still runs on Node 20.
+
+One sync of a record runs at a time. The Mac app syncing on its own, a launchd job and `evda sync`
+at a terminal wait for each other; if a sync is still running after twenty seconds, the second says
+"A sync of this EVÐA is already running. Try again in a moment." and changes nothing. A sync that
+crashed leaves nothing in the way: the next one sees the process is gone and goes ahead.
+
 Organizing is on from the start. Setup installs the morning organize on a Mac (a launchd job that
 runs your own Claude each morning at 8:00, or when the computer wakes), says so in one line, and
 offers off: answer no during setup, pass `--no-routines`, or later run `evda routine morning

package/README.md

@@ -76,6 +76,7 @@ apply places only what is new, in the record's own folders.
     evda_operating_layer   AGENTS.md, read first every session
     evda_recent            the last few days of the record
     evda_write             your words, verbatim, appended to today's daily file, with one line of context labeled as not yours. It takes no path and never edits
+    evda_record_correction one dated line appended to AGENTS.md's "What I have been taught", outside the installer's block. Never edits an earlier entry
     evda_import            what another AI said about you, filed under record/imports with its source and date
     evda_search            plain text search inside the record, on this machine
     evda_circles           your circles and their policies
@@ -91,15 +92,23 @@ apply places only what is new, in the record's own folders.
     evda_write_skill       writes or revises a skill at .claude/skills/<name>/SKILL.md. Never outside that folder, never a rule about your life
     evda_create_subrecord  an EVÐA inside this one, with the four roles and its own AGENTS.md, then doctor. Your evda.json changes only on bounded with confirmed: true
     evda_doctor            evda doctor, as a report
-    evda_check_update      whether newer EVDA tooling exists. The only tool that reaches the network
+    evda_pair              a one-time code and a QR code to scan for your phone, paired to the computer this server runs on; the phone gets only the parts named, and is added on its own once it uses the code
+    evda_finish_pairing    waits, at most two minutes, for the phone to use its code, and says when it is in
+    evda_sync_devices      adds a phone that used its code, takes in what your devices wrote, sends what changed
+    evda_devices           the devices paired with your EVÐA on this computer, what each reads, and when it was last heard from
+    evda_sync_status       per device what is waiting, sent and confirmed, and whether a sync is running. Reads only
+    evda_remove_device     removes a device; without confirm: true it only says what removing would do, for your yes
+    evda_check_update      whether newer EVDA tooling exists
 
-Every write appends, refuses anything shaped like a password, key or token, and says the path it wrote. The one call that leaves this machine is `evda_check_update` asking the npm registry for a version number; it carries nothing from the record and installs nothing, and the update itself is a command you run in a terminal. `evda connect` prints the setup for your record, with its path filled in:
+Every write appends, refuses anything shaped like a password, key or token, and says the path it wrote. Two kinds of call leave this machine. `evda_check_update` asks the npm registry for a version number; it carries nothing from the record and installs nothing, and the update itself is a command you run in a terminal. The device tools talk to the relay that carries your EVÐA between your own devices, and everything they send is sealed here first: the relay cannot read it. `evda connect` prints the setup for your record, with its path filled in:
 
 ```bash
 claude mcp add --scope user evda -- /path/to/node /path/to/evda.mjs mcp ~/my-evda   # Claude Code
 codex mcp add evda -- /path/to/node /path/to/evda.mjs mcp ~/my-evda                 # Codex
 ```
 
+**One layer, sized per app.** `evda_operating_layer` serves the core and AGENTS.md to every app, but a section that only makes sense with a shell (scripts to run, hosts to ssh to, local MCP servers) is noise in a chat app. Put `<!-- evda:surface terminal -->` on the line right after a `## ` heading and that section, with its subsections, goes only to coding agents (Claude Code, Codex). Every other app, including one the server has never heard of, gets the rest, in as few parts as its tool result limit allows, and is told which sections were left out. A record with no marker reads the same everywhere. The server knows the app by `initialize`'s `clientInfo` name, and the remote server logs that name and version, nothing else of it.
+
 For the Claude desktop app, add the same command under `mcpServers` in `claude_desktop_config.json` (Settings, then Developer, then Edit Config) and restart the app. `create-evda` prints all three at the end of setup.
 
 **The skill.** `skills/evda/SKILL.md` (Agent Skills format) tells Claude Code to act as Iris through the tools: load the operating layer first, file verbatim, never quiz, circles only on your yes. `evda skill install` copies it to `~/.claude/skills/evda/`; setup offers it.

package/bin/evda.mjs

@@ -26,7 +26,7 @@ import { holderOf, HOLDER_KINDS } from "../lib/manifest.mjs";
 import { EvdaError, isEntry } from "../lib/errors.mjs";
 import { publishCommand } from "../lib/publish.mjs";
 import { checkForUpdate, summarize, stampInstalledVersion } from "../lib/update-check.mjs";
-import { planCircles, coverage, declare, deviceCircles, planBeside } from "../lib/circle-plan.mjs";
+import { planCircles, coverage, declare, deviceCircles, planBeside, defaultParts } from "../lib/circle-plan.mjs";
 import { circleIndex, grantView } from "../lib/filechanges.mjs";
 import { mountRoot } from "../lib/declarations.mjs";
 import { excluder } from "../lib/sync-rules.mjs";
@@ -34,7 +34,9 @@ import { parity, formatParity } from "../lib/parity.mjs";
 import { note, releaseNote, ownerSearch, readContext, readersFor, describeReaders, parseReaders, READ_BY } from "../lib/readers.mjs";
 import { runHook } from "../lib/guard.mjs";
 import { markdownFiles } from "../lib/circles.mjs";
-import { refuseSecrets, message as messageTool, replies as repliesTool } from "../lib/tools.mjs";
+import { refuseSecrets, message as messageTool, replies as repliesTool, acknowledgeEntry as acknowledgeTool, acknowledgements as acknowledgementsTool } from "../lib/tools.mjs";
+import * as pairing from "../lib/pairing.mjs";
+import { watchRecord, watchRelay } from "../lib/watch.mjs";
 
 const HELP = `evda: operate an EVDA. The files are the truth; this is optional.
 
@@ -100,6 +102,10 @@ const HELP = `evda: operate an EVDA. The files are the truth; this is optional.
                                  run doctor. Writes a reversal manifest beside the proposal
   evda gather revert <manifest> [--force]
                                  undo an apply byte for byte; refused when a placed file was edited
+  evda secret <file> [dir] [--keychain <path>]
+                                 a credential note (in Credentials/, or --into a path of its own) with
+                                 every "in your Keychain" pointer read back and filled in, to this
+                                 terminal only (HQ-1916). No MCP tool reads a value this way
   evda look-back [dir] [--model M]
                                  the week, read back by the owner's claude -p, appended to a report
   evda routine <morning|weekly> [dir] [--launchd] [--install] [--uninstall]
@@ -112,6 +118,27 @@ const HELP = `evda: operate an EVDA. The files are the truth; this is optional.
                                  add the preset's folders and manifests. Only adds: an existing
                                  manifest that differs is a CONFLICT and is left as it is
   evda preset diff <id> [dir]    what the preset has that this record does not
+  evda pair [dir] [--name phone] [--parts journal[,people]] [--json]
+                                 a one-time code (and a QR link) for a phone to join this EVÐA. It
+                                 works once, for 10 minutes, and gives the device only the parts named
+                                 (with no --parts, the part that holds the day folder)
+  evda pair --finish [dir] [--json]
+                                 add a device that used its code, without a full sync. It never waits:
+                                 while a sync runs it says so, and that sync adds the device itself
+  evda devices [dir] [--json]    the devices paired with this EVÐA, and what each reads
+  evda watch [dir]               one line (CHANGED <n>) per burst of saves in the record, and INCOMING
+                                 when a device sent something, for the Mac app's sync; runs until stopped
+  evda sync-status [dir] [--json]
+                                 what is syncing on this computer now, since when, and what is still owed
+  evda remove <device> [dir]     remove a device: it adds nothing more and receives nothing new
+  evda sync [dir]                add devices that used their code, take in what they sent, send what
+                                 changed. Pairing needs Node 22.13 or newer; --relay <url> for another relay
+                                 One sync of a record runs at a time (the Mac app, launchd, a terminal); a
+                                 second waits for it, then says so in one line if it is still running
+                                 --json on pair, devices, remove and sync prints data for an app, no ids
+  evda compact [dir] [--yes]     give back the space this computer's sync state keeps for sealed copies
+                                 nothing needs: media (which travels by name only) and copies no device is
+                                 still owed. Shows what it would remove; --yes removes them
   evda status [dir]              one screen summary
   evda publish public [dir] --out <dir> --key <seed file>
                                  the public circle as a signed plaintext export; refuses (exit 2) on a
@@ -123,6 +150,10 @@ const HELP = `evda: operate an EVDA. The files are the truth; this is optional.
                                  circles and grants roles and their folders; moves and changes no file.
                                  A circle rooted at "" is written as the root itself, and a circle
                                  already declared keeps its id, release, rules, mount and policy
+  evda circles default [--dry-run] [--json] [dir]
+                                 split a record that has no parts into the default two: journal (the
+                                 day files and captures) and private (everything else). A record that
+                                 has parts is left as it is. --dry-run says what it would make
   evda circles check [--plan <file>] [dir]
                                  every syncable file in exactly one circle (CHECKED n files); fails on a
                                  file no circle covers, and on a symlink, iCloud stub or oversize file.
@@ -141,8 +172,14 @@ const HELP = `evda: operate an EVDA. The files are the truth; this is optional.
   evda replies [--peek] [--in dir] [--json]
                                  the owner's replies not seen yet, marked seen unless --peek; read
                                  under read_by as the AI $EVDA_READER names (claude, local, ...)
+  evda acknowledge <path> [--section "## HH:MM"] [--note "<one line>"] [--by NAME] [--in dir] [--json]
+                                 you said a weighty entry back to the owner: one mark beside the
+                                 record, so no other reader says it again. Already marked prints who
+                                 did it and writes nothing. No path lists every mark
   evda search <words> [dir]      your own search, on this device, no model; just-noted and sealed entries included and marked
   evda readers [dir]             which AI reads each part of the record, from read_by
+  evda browse [dir] [--folder F | --pins | --operating | --today | --index | --open P | --attachments | --attach P]  one folder of the record, the pinned folders, the files on how it works, today's note, every text file's path, one file, every PDF, image and other attachment's path, or one attachment, as JSON (the app)
+  evda capture [dir] < words     append the words on stdin to today's note, verbatim, under a new timestamped section (the app)
   evda local-model               how to run a model on your own computer and point a circle at it
   evda guard                     the Claude Code read guard (a PreToolUse hook; reads the tool call on stdin)
   evda where                     which EVDA the locator resolves to, and by which rule
@@ -172,7 +209,7 @@ function isDirArg(a) {
 }
 
 // `--name value` or `--name=value`. The value of a `--name value` pair is not a positional.
-const VALUE_FLAGS = ["to", "kind", "name", "role", "by", "as", "model", "project", "hour", "weekday", "out", "key", "plan", "device", "shadow", "record-id", "env-file", "port", "host", "public-url", "log", "lifeline", "ttl"];
+const VALUE_FLAGS = ["open", "folder", "to", "kind", "name", "role", "by", "as", "model", "project", "hour", "weekday", "out", "key", "plan", "device", "shadow", "record-id", "env-file", "port", "host", "public-url", "log", "lifeline", "ttl", "parts", "relay"];
 function flagValue(args, name) {
   const eq = args.find((a) => a.startsWith(`--${name}=`));
   if (eq) return eq.slice(name.length + 3);
@@ -259,7 +296,7 @@ async function main(argv) {
 
     case "version":
     case "--version":
-      console.log(`evda tool schema ${SCHEMA_VERSION}`);
+      console.log(`evda ${packageVersion()} (tool schema ${SCHEMA_VERSION})`);
       return 0;
 
     case "init": {
@@ -356,6 +393,25 @@ async function main(argv) {
       throw new EvdaError("usage: evda gather scan <source>... | questions <proposal> | answer <proposal> <question> <value> | show <proposal> | apply <proposal> --into <record> | revert <manifest>", { exit: 2 });
     }
 
+    // HQ-1916: a credential note's Keychain pointers, read back and printed to this terminal only.
+    // No MCP tool calls into this, on purpose -- the whole point of the Keychain move is that no AI
+    // reads the value; only the owner does, on their own Mac.
+    case "secret": {
+      const { dir, rest } = pickDir(args);
+      const file = rest[0];
+      if (!file) throw new EvdaError("usage: evda secret <file> [dir] [--keychain <path>]", { exit: 2 });
+      const g2 = await import("../lib/gather.mjs");
+      const k = await import("../lib/keychain.mjs");
+      const abs = file.includes("/") ? resolve(dir, file) : join(dir, g2.CREDENTIALS, file);
+      if (!existsSync(abs)) throw new EvdaError(`REFUSED: no file at ${abs}.`, { code: "NOT_FOUND", exit: 2 });
+      const text = readFileSync(abs, "utf8");
+      const r = k.resolvePointers(text, { keychainPath: flagValue(args, "keychain") ?? process.env.EVDA_KEYCHAIN_PATH ?? null });
+      console.log(r.text);
+      if (!r.resolved && !r.failed) console.log(`\nSKIPPED Keychain: ${abs} holds no "in your Keychain" pointer -- its value(s) never left the file (not macOS at apply, or the write failed then)`);
+      else console.log(`\nCHECKED ${r.resolved} Keychain pointer(s) resolved, ${r.failed} could not be read`);
+      return r.failed ? 1 : 0;
+    }
+
     case "look-back": {
       const { dir } = pickDir(args);
       const { lookBack } = await import("../lib/organize.mjs");
@@ -492,6 +548,75 @@ async function main(argv) {
       return 0;
     }
 
+    case "pair": {
+      const { dir } = pickDir(args);
+      // --finish: add a device that used its code, without a full sync (HQ-2017).
+      if (args.includes("--finish")) {
+        if (args.includes("--json")) console.log(JSON.stringify(await pairing.finishData(dir, { relay: flagValue(args, "relay") })));
+        else for (const line of await pairing.finish(dir, { relay: flagValue(args, "relay") })) console.log(line);
+        return 0;
+      }
+      const r = await pairing.pair(dir, { name: flagValue(args, "name"), parts: flagValue(args, "parts"), relay: flagValue(args, "relay") });
+      // --json is for an app (the EVÐA Mac app, HQ-1925): the code and its QR link, and nothing with an id.
+      if (args.includes("--json")) console.log(JSON.stringify({ name: r.name, code: r.code, qr: r.qr, computer: r.computer, expiresAt: r.expiresAt, parts: r.parts }));
+      else for (const line of r.lines) console.log(line);
+      return 0;
+    }
+
+    case "sync-status": {
+      // What is syncing on this computer now, for the Mac app (HQ-2041): who holds the state and
+      // since when, and how much is still owed. Never waits.
+      const { dir } = pickDir(args);
+      const r = await pairing.statusData(dir, { relay: flagValue(args, "relay") });
+      if (args.includes("--json")) console.log(JSON.stringify(r));
+      else console.log(r.holder ? `Syncing: ${r.holder.by === "tick" ? "the background sync" : r.holder.by === "app" ? "the EVÐA app" : "a command"} (${r.holder.op}) since ${new Date(r.holder.since).toLocaleTimeString()}.` : "Nothing is syncing.", r.owed ? `${r.owed} change(s) still owed to a device.` : "");
+      return 0;
+    }
+
+    case "devices":
+    case "sync": {
+      const { dir } = pickDir(args);
+      const relay = flagValue(args, "relay");
+      if (args.includes("--json")) {
+        console.log(JSON.stringify(cmd === "devices" ? await pairing.deviceData(dir, { relay }) : await pairing.syncData(dir, { relay })));
+        return 0;
+      }
+      const lines = await pairing[cmd](dir, { relay });
+      for (const line of lines) console.log(line);
+      return 0;
+    }
+
+    case "watch": {
+      // For the Mac app (HQ-2068): one line a burst of saves in the record, so it syncs in seconds.
+      // Runs until it is stopped; the app runs the sync, this only says when.
+      const { dir } = pickDir(args);
+      watchRecord(dir, (paths) => console.log(`CHANGED ${paths.length}`));
+      // And the relay: a device's note says INCOMING within seconds, so the app syncs it in then.
+      const relay = flagValue(args, "relay");
+      if (!pairing.pairingUnsupported()) watchRelay(() => pairing.inboundMailboxes(dir, { relay }), () => console.log("INCOMING"));
+      console.log("WATCHING");
+      return await new Promise(() => undefined);
+    }
+
+    case "compact": {
+      const { dir } = pickDir(args);
+      for (const line of await pairing.compact(dir, { yes: args.includes("--yes") })) console.log(line);
+      return 0;
+    }
+
+    case "remove": {
+      // The device's name comes first and is never read as the record, even when a folder by
+      // that name sits in the working directory.
+      const values = new Set(VALUE_FLAGS.map((n) => args.indexOf(`--${n}`)).filter((i) => i >= 0).map((i) => i + 1));
+      const at = args.findIndex((a, i) => !a.startsWith("--") && !values.has(i));
+      const name = at >= 0 ? args[at] : flagValue(args, "name");
+      const { dir } = pickDir(at >= 0 ? args.filter((_, i) => i !== at) : args);
+      const lines = await pairing.remove(dir, name, { relay: flagValue(args, "relay") });
+      if (args.includes("--json")) console.log(JSON.stringify({ removed: String(name).trim(), lines }));
+      else for (const line of lines) console.log(line);
+      return 0;
+    }
+
     case "doctor": {
       const { dir, via } = pickDir(args);
       return doctor(dir, { via }).exit;
@@ -524,7 +649,7 @@ async function main(argv) {
       let body = args.join(" ");
       if (body === "-" || body === "") body = readFileSync(0, "utf8");
       const r = messageTool(openEvda(dir), { title, body, ...(from === undefined ? {} : { from }) });
-      console.log(`Sent the message ${r.id}, filed at ${r.path}.`);
+      console.log(`Filed the message ${r.id} at ${r.path}. This does not confirm it reached the owner's phone.`);
       return 0;
     }
 
@@ -540,6 +665,33 @@ async function main(argv) {
       return 0;
     }
 
+    case "acknowledge": {
+      // HQ-2060. A note may hold a slash, so the record is --in <dir> or the locator, as with
+      // note and message. No path lists what every reader has already acknowledged.
+      const take = (flag) => { const i = args.indexOf(flag); if (i < 0) return undefined; const v = args[i + 1]; if (v === undefined) throw new EvdaError(`${flag} needs a value`, { exit: 2 }); args.splice(i, 2); return v; };
+      const json = args.includes("--json") && (args.splice(args.indexOf("--json"), 1), true);
+      const dirArg = take("--in");
+      const section = take("--section");
+      const note = take("--note");
+      const by = take("--by");
+      const dir = locate({ explicit: dirArg }).dir;
+      const evda = openEvda(dir);
+      const path = args.filter((a) => !a.startsWith("--")).join(" ").trim();
+      if (!path) {
+        const r = acknowledgementsTool(evda);
+        if (json) { console.log(JSON.stringify(r, null, 2)); return 0; }
+        for (const m of r.marks) console.log(`- ${m.key}  (${m.by ?? "unknown"}, ${m.at}): ${m.note}`);
+        console.log(`CHECKED ${r.count} acknowledged entr${r.count === 1 ? "y" : "ies"}`);
+        return 0;
+      }
+      const r = acknowledgeTool(evda, { path, ...(section === undefined ? {} : { section }), ...(note === undefined ? {} : { note }), ...(by === undefined ? {} : { by }) });
+      if (json) { console.log(JSON.stringify(r, null, 2)); return 0; }
+      const what = r.section ? `${r.path} "${r.section}"` : r.path;
+      if (!r.first) console.log(`Already acknowledged by ${r.by ?? "an earlier reader"} at ${r.at}: ${r.note}\nNothing was written. Say nothing about ${what} unless the owner brings it up.`);
+      else console.log(`Marked ${what} acknowledged, as ${r.by}. You reached it first, so every later reader sees this mark and stays quiet.`);
+      return 0;
+    }
+
     case "release": {
       const { dir, entry } = pickReleaseArgs(args);
       const r = releaseNote(openEvda(dir), entry);
@@ -559,6 +711,37 @@ async function main(argv) {
       return 0;
     }
 
+    case "browse": {
+      // The owner's app reads the record through this (HQ-2038): the pinned folders, one folder's
+      // children, or one file opened, each as one JSON line. The rules are lib/browse.mjs.
+      const { dir } = pickDir(args);
+      const evda = openEvda(dir);
+      const b = await import("../lib/browse.mjs");
+      const bctx = b.browseContext(evda);
+      const open = flagValue(args, "open");
+      const folder = flagValue(args, "folder");
+      const attach = flagValue(args, "attach");
+      const answer = attach !== undefined ? b.attachEntry(evda, attach, { bctx }) : args.includes("--attachments") ? b.attachments(evda, { bctx }) : open !== undefined ? b.openEntry(evda, open, { bctx }) : args.includes("--pins") ? b.pins(evda, { bctx }) : args.includes("--operating") ? b.operating(evda, { bctx }) : args.includes("--today") ? b.today(evda, { bctx }) : args.includes("--index") ? b.index(evda, { bctx }) : b.browse(evda, folder ?? "", { bctx });
+      // Written to the end before returning: on macOS a pipe write is asynchronous, and the exit
+      // that follows cut anything past the pipe's 64 KB buffer (his 71 KB CLAUDE.md, HQ-2038).
+      await new Promise((done) => process.stdout.write(`${JSON.stringify(answer)}\n`, done));
+      return 0;
+    }
+
+    case "capture": {
+      // The app's capture box (HQ-2038): the words come on stdin, verbatim, and are appended to
+      // today's daily note under a new timestamped section, by the same write evda_write makes.
+      const { dir } = pickDir(args);
+      const evda = openEvda(dir);
+      const chunks = [];
+      for await (const c of process.stdin) chunks.push(c);
+      const words = Buffer.concat(chunks).toString("utf8");
+      const { capture } = await import("../lib/browse.mjs");
+      const r = capture(evda, words);
+      await new Promise((done) => process.stdout.write(`${JSON.stringify(r)}\n`, done));
+      return 0;
+    }
+
     case "readers": {
       const { dir } = pickDir(args);
       const evda = openEvda(dir);
@@ -839,6 +1022,16 @@ async function main(argv) {
         console.log(`wrote ${written.length} files: ${written.map((p) => relative(dir, p)).join(", ")}`);
         return 0;
       }
+      if (sub === "default") {
+        // The default parts (HQ-1925), for a record that has none: the app's one button, on the
+        // owner's yes. --dry-run is the question and writes nothing.
+        const r = defaultParts(dir, { dryRun: args.includes("--dry-run") });
+        if (args.includes("--json")) { console.log(JSON.stringify(r)); return 0; }
+        if (r.declared) console.log(`Split into parts: ${r.parts.join(", ")}. Nothing in your files moved.`);
+        else if (r.needed) console.log(`Not split into parts yet. Saying yes makes: ${r.parts.join(", ")}. Nothing was written.`);
+        else console.log(`This EVÐA is already split into parts: ${r.parts.join(", ")}. Nothing was written.`);
+        return 0;
+      }
       if (sub === "check") {
         const evda = openEvda(dir);
         // Without --plan, the plan kept beside the circles (`<circles role>/plan.json`) says what is
@@ -855,7 +1048,7 @@ async function main(argv) {
         if (r.checked === 0) { console.log("FAIL CHECKED 0: nothing was examined"); return 1; }
         return r.problems.length ? 1 : 0;
       }
-      throw new EvdaError("circles needs plan, declare or check", { exit: 2 });
+      throw new EvdaError("circles needs plan, declare, default or check", { exit: 2 });
     }
 
     case "parity": {
@@ -905,7 +1098,25 @@ async function main(argv) {
 
 // Through realpath: an installed bin is a symlink and resolve() does not follow it (see the same
 // guard in create-evda.mjs, and test/bins.test.mjs).
+/**
+ * A command the EVÐA app runs ends when the app does (HQ-2041). The app names itself in
+ * EVDA_PARENT_PID; once this process's parent is no longer that pid (the app quit or crashed and
+ * this process was handed to launchd), it stops. A lock it held is then stale and taken over.
+ */
+export function watchParent(env = process.env, { ppid = () => process.ppid, exit = (c) => process.exit(c), everyMs = 1000 } = {}) {
+  const want = Number(env.EVDA_PARENT_PID);
+  if (!Number.isInteger(want) || want <= 0) return null;
+  const check = () => {
+    if (ppid() !== want) exit(1);
+  };
+  check();
+  const t = setInterval(check, everyMs);
+  t.unref();
+  return t;
+}
+
 if (process.argv[1] && isEntry(process.argv[1], import.meta.url)) {
+  watchParent();
   main(process.argv.slice(2)).then(
     (code) => process.exit(code),
     (e) => {

package/create-evda.mjs

@@ -3,7 +3,7 @@
 //
 //   create-evda <dir> [--agent-name NAME] [--owner NAME] [--purpose TEXT] [--voice TEXT]
 //                     [--platform claude|chatgpt|gemini|cursor|other] [--training-off] [--yes]
-//                     [--filing everything|asked] [--no-prompt-hook]
+//                     [--filing everything|asked] [--no-prompt-hook] [--no-parts]
 //                     [--name NAME] [--layers record,ledger[,circles]] [--preset ID|none] [--force]
 //
 // On a terminal, any setup answer not given as a flag is asked, one question at a time, and setup
@@ -13,7 +13,10 @@
 //
 // Writes the manifest, the operating layer with the owner's answers in its owner section, the
 // loaders for the tools that do not read AGENTS.md on their own, the corpus, the ledger, and
-// .evda/. Then runs `evda doctor` on what it wrote. It creates no example notes: an empty record
+// .evda/. Splits the record into its default parts (HQ-1925): journal, the day files and captures,
+// and private, everything else, both held by this computer, so a phone can be added with no
+// terminal step (--no-parts leaves it unsplit, for parts declared by hand). Then runs `evda doctor`
+// on what it wrote. It creates no example notes: an empty record
 // that fills with a real life is the product. The one file it writes under record/ is today's
 // daily file holding a true event, the record's own creation, so the first session has something
 // dated to read and the owner sees where their words go.
@@ -30,12 +33,14 @@ import { readPointer, setPointer, pointerPath } from "./lib/locate.mjs";
 import { FOLDER_MANIFEST } from "./lib/folders.mjs";
 import { EvdaError } from "./lib/errors.mjs";
 import { clients, installSkill, installGuard } from "./lib/connect.mjs";
+import { everyChatSetupLines } from "./lib/every-chat.mjs";
 import { defaultRoutines, installAtSetup } from "./lib/routines.mjs";
 import { installHook } from "./lib/hooks.mjs";
 import { applyPreset, listPresets, planLines, presetIds, NONE } from "./lib/presets.mjs";
 import { FILING_MODES } from "./lib/day-file.mjs";
 import { installPromptHook } from "./lib/hooks.mjs";
-import { PLATFORMS, PLATFORM_KEYS, LOADERS, DESKTOP_FILESYSTEM, DICTATION, DEFAULT_AGENT_NAME, platformKey, fillOwnerSection, aiLine, interview, trainingSection, termsSection, readerFor, INTRO } from "./lib/setup.mjs";
+import { defaultParts } from "./lib/circle-plan.mjs";
+import { PLATFORMS, PLATFORM_KEYS, PARTS_LINE, LOADERS, DESKTOP_FILESYSTEM, DICTATION, DEFAULT_AGENT_NAME, platformKey, fillOwnerSection, aiLine, interview, trainingSection, termsSection, readerFor, INTRO } from "./lib/setup.mjs";
 import { describeReaders, parseReaders } from "./lib/readers.mjs";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
@@ -65,13 +70,13 @@ const FOLDER_TYPES = {
   messages: "message",
 };
 
-const USAGE = `usage: create-evda <dir> [--agent-name NAME] [--owner NAME] [--purpose TEXT] [--voice TEXT] [--platform ${PLATFORM_KEYS.join("|")}] [--training-off] [--filing everything|asked] [--no-prompt-hook] [--yes] [--name NAME] [--kind person|agent|company] [--id ATLAS-ID] [--layers record,ledger] [--skill] [--routines morning,weekly] [--preset ${presetIds().join("|")}|none] [--use] [--no-pointer] [--no-guard]`;
+const USAGE = `usage: create-evda <dir> [--agent-name NAME] [--owner NAME] [--purpose TEXT] [--voice TEXT] [--platform ${PLATFORM_KEYS.join("|")}] [--training-off] [--filing everything|asked] [--no-prompt-hook] [--no-parts] [--yes] [--name NAME] [--kind person|agent|company] [--id ATLAS-ID] [--layers record,ledger] [--skill] [--routines morning,weekly] [--preset ${presetIds().join("|")}|none] [--use] [--no-pointer] [--no-guard]`;
 
 export function parseArgs(argv) {
   const opts = {
     layers: ["record", "ledger"], force: false, name: null, owner: "", kind: "person", id: null, pointer: true, use: false,
     yes: false, trainingOff: false, agentName: null, purpose: "", voice: "", platform: null, platformName: null,
-    skill: null, routines: null, preset: null, guard: true, filing: null, promptHook: true,
+    skill: null, routines: null, preset: null, guard: true, filing: null, promptHook: true, parts: true,
   };
   const args = argv.flatMap((a) => {
     const eq = /^(--[a-z-]+)=([\s\S]*)$/.exec(a);
@@ -92,6 +97,7 @@ export function parseArgs(argv) {
     else if (a === "--skill") opts.skill = true;
     else if (a === "--no-guard") opts.guard = false;
     else if (a === "--no-prompt-hook") opts.promptHook = false;
+    else if (a === "--no-parts") opts.parts = false;
     else if (a === "--filing") {
       opts.filing = value(++i, a).trim().toLowerCase();
       if (!FILING_MODES.includes(opts.filing)) throw new EvdaError(`--filing takes ${FILING_MODES.join(" or ")}, got ${args[i]}`, { exit: 2 });
@@ -302,6 +308,12 @@ export async function main(argv, io = null) {
     for (const l of planLines(plan)) log(l);
     log("");
   }
+  // The default parts, after the preset so its folders exist, and before doctor so doctor reads them.
+  if (opts.parts !== false) {
+    const parts = defaultParts(dir);
+    log(parts.parts.includes("journal") ? PARTS_LINE : `parts: ${parts.parts.join(", ")}`);
+    log("");
+  }
   const report = doctor(dir, { out: log, via: "create-evda" });
   if (report.exit !== 0) {
     console.error("\ncreate-evda wrote the layout but doctor does not pass on it. That is a bug in create-evda; the output above says where.");
@@ -321,7 +333,11 @@ export async function main(argv, io = null) {
   }
   log("");
   log("Or connect your AI to this record from any folder, through the evda MCP server. No key and no model call in EVÐA:");
-  for (const c of clients(dir)) if (c.key !== "project") { log(`  ${c.label}:`); for (const l of c.text.split("\n")) log(`    ${l}`); }
+  for (const c of clients(dir)) if (c.key !== "project" && c.key !== "every-chat") { log(`  ${c.label}:`); for (const l of c.text.split("\n")) log(`    ${l}`); }
+  // The every-chat line (HQ-2205), from the one source: a chat that never calls an evda tool is
+  // reached only by the app's own every-chat setting.
+  log("");
+  for (const l of everyChatSetupLines(manifest.filing ?? null)) log(l);
   if (opts.skill) {
     const r = installSkill({ env: io?.env ?? process.env });
     log("");