create-evda 0.1.6 → 0.1.8

package/lib/routines.mjs

@@ -1,5 +1,6 @@
-// Starter routines: a morning organize and a weekly look back, each optional, each scheduled only on
-// the owner's yes.
+// Starter routines: a morning organize and a weekly look back. The morning organize is on by default
+// (HQ-1246, his call 2026-09-27: "We know that it needs to be organizing and stuff 100%"); setup says
+// so in one line and offers off. The weekly look back stays offered, never on without a yes.
 //
 // The first choice is Claude's own scheduler. A local scheduled task in the Claude desktop app runs
 // on this machine with access to this folder (https://code.claude.com/docs/en/desktop-scheduled-tasks).
@@ -10,8 +11,8 @@
 // calendar, through a login shell so the owner's `claude` is on PATH. `--install` writes it and
 // loads it; nothing else here schedules anything.
 
-import { mkdirSync, writeFileSync, existsSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { mkdirSync, writeFileSync, existsSync, realpathSync, rmSync, statSync } from "node:fs";
+import { delimiter, join, resolve, sep } from "node:path";
 import { homedir } from "node:os";
 import { spawnSync } from "node:child_process";
 import { openEvda, holderOf } from "./manifest.mjs";
@@ -38,6 +39,43 @@ export const ROUTINES = {
 };
 export const ROUTINE_KEYS = Object.keys(ROUTINES);
 
+// EVDA_ROUTINES_FALSIFY=opt-in makes the default nothing, the state before HQ-1246, for the test
+// that shows the default is what installs it.
+export function defaultRoutines(env = process.env) {
+  return (env.EVDA_ROUTINES_FALSIFY ?? "").split(",").map((m) => m.trim()).includes("opt-in") ? [] : ["morning"];
+}
+
+// The owner's claude, found once at setup: EVDA_CLAUDE, then PATH, then where the installers put it.
+// A launchd job runs a login shell, which does not read .zshrc, so a claude on PATH only through
+// .zshrc is invisible to it; the job carries the path found here instead.
+export function findClaude(env = process.env) {
+  if (env.EVDA_CLAUDE) return env.EVDA_CLAUDE;
+  const home = env.HOME ?? homedir();
+  const dirs = [...(env.PATH ?? "").split(delimiter), join(home, ".local", "bin"), join(home, ".claude", "local"), "/opt/homebrew/bin", "/usr/local/bin"];
+  for (const d of dirs) {
+    if (!d) continue;
+    const p = join(d, "claude");
+    try { if (statSync(p).isFile()) return p; } catch {}
+  }
+  return null;
+}
+
+// macOS keeps a scheduled job out of these folders unless the shell running it has Full Disk Access.
+export function protectedLocation(dir, env = process.env) {
+  const home = env.HOME ?? homedir();
+  let real = resolve(dir);
+  try { real = realpathSync(real); } catch {}
+  let realHome = home;
+  try { realHome = realpathSync(home); } catch {}
+  for (const h of new Set([home, realHome])) {
+    for (const f of ["Documents", "Desktop", "Downloads", join("Library", "Mobile Documents")]) {
+      const base = join(h, f);
+      if (real === base || real.startsWith(base + sep) || resolve(dir).startsWith(base + sep)) return f === join("Library", "Mobile Documents") ? "iCloud Drive" : f;
+    }
+  }
+  return null;
+}
+
 const q = (s) => (/^[A-Za-z0-9_./:@=+-]+$/.test(s) ? s : `'${String(s).replace(/'/g, "'\\''")}'`);
 
 // The shell command a routine runs, with this machine's node and this package's bin.
@@ -58,7 +96,7 @@ export function desktopInstructions(key, dir) {
     `  Name:         ${r.id}`,
     `  Schedule:     ${r.when}`,
     `  Folder:       ${resolve(dir)}`,
-    "  Instructions: Run this command in the folder, then tell me the report path it prints and anything it SKIPPED:",
+    "  Instructions: Run this command in the folder, then tell me the report path it prints and anything that did not run:",
     `                ${routineCommand(key, dir)}`,
     "",
     "A local routine runs while the app is open and the computer is awake.",
@@ -72,7 +110,7 @@ export function label(key, evda) {
 
 const xml = (s) => String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 
-export function launchdPlist(key, dir, { home = homedir() } = {}) {
+export function launchdPlist(key, dir, { home = homedir(), claude = null } = {}) {
   const evda = openEvda(dir);
   const r = ROUTINES[key];
   const log = join(home, "Library", "Logs", "evda", `${r.id}.log`);
@@ -93,6 +131,7 @@ export function launchdPlist(key, dir, { home = homedir() } = {}) {
     "  <dict>",
     cal,
     "  </dict>",
+    ...(claude ? ["  <key>EnvironmentVariables</key>", "  <dict>", `    <key>EVDA_CLAUDE</key><string>${xml(claude)}</string>`, "  </dict>"] : []),
     `  <key>StandardOutPath</key><string>${xml(log)}</string>`,
     `  <key>StandardErrorPath</key><string>${xml(log)}</string>`,
     "</dict>",
@@ -101,31 +140,116 @@ export function launchdPlist(key, dir, { home = homedir() } = {}) {
   ].join("\n");
 }
 
-// Write the launchd job and load it. `agentsDir` and `load` exist so tests never touch the real
-// ~/Library/LaunchAgents or launchctl.
-export function installLaunchd(key, dir, { agentsDir = process.env.EVDA_LAUNCH_AGENTS ?? join(homedir(), "Library", "LaunchAgents"), load = process.env.EVDA_NO_LAUNCHCTL !== "1", home = homedir() } = {}) {
-  if (process.platform !== "darwin" && load) throw new EvdaError("REFUSED: launchd is macOS only. Use the Claude desktop routine instead. Nothing was written.", { exit: 2 });
+// launchctl is off when the env handed in says so OR this process's own env does. A caller that
+// hands in a partial env (a test's `{ HOME }`) no longer drops the guard and loads a real job, which
+// is how io.evda.evda-morning-organize.*.atlas jobs stayed loaded after test runs.
+export const noLaunchctl = (env = process.env) => env.EVDA_NO_LAUNCHCTL === "1" || process.env.EVDA_NO_LAUNCHCTL === "1";
+
+// How launchctl is run. EVDA_LAUNCHCTL names a stand-in binary so the tests can drive the whole CLI
+// without the real launchctl; `launchctl` in the options is the same seam for in-process callers.
+export function runLaunchctl(args, env = process.env) {
+  const r = spawnSync(env.EVDA_LAUNCHCTL || "launchctl", args, { encoding: "utf8" });
+  return { status: r.status, stdout: r.stdout ?? "", stderr: r.stderr ?? "" };
+}
+
+const falsified = (env, mode) => (env.EVDA_ROUTINES_FALSIFY ?? "").split(",").map((m) => m.trim()).includes(mode);
+
+// Unload a job by its label, not by its file: a job whose file is already gone, or was loaded from
+// another path, is still unloaded. EVDA_ROUTINES_FALSIFY=skip-bootout skips it (the HQ-1246 bug:
+// the file went, the job stayed loaded), for the tests.
+function bootout(target, env, launchctl) {
+  if (!falsified(env, "skip-bootout")) launchctl(["bootout", target]);
+}
+
+// Loaded or not, asked of launchd itself: `launchctl print gui/<uid>/<label>` exits 0 only for a
+// loaded job (113 when there is none).
+const isLoaded = (target, launchctl) => launchctl(["print", target]).status === 0;
+
+// Write the launchd job and load it. `agentsDir`, `load` and `launchctl` exist so tests never touch
+// the real ~/Library/LaunchAgents or launchctl. A job already loaded under this label is unloaded
+// first, so a second install replaces it rather than failing to load a duplicate.
+export function installLaunchd(key, dir, { env = process.env, home = env.HOME ?? homedir(), agentsDir = env.EVDA_LAUNCH_AGENTS ?? process.env.EVDA_LAUNCH_AGENTS ?? join(home, "Library", "LaunchAgents"), load = !noLaunchctl(env), claude = findClaude(env), launchctl = (a) => runLaunchctl(a, env) } = {}) {
+  if (process.platform !== "darwin" && load && !env.EVDA_LAUNCHCTL) throw new EvdaError("REFUSED: launchd is macOS only. Use the Claude desktop routine instead. Nothing was written.", { exit: 2 });
   const evda = openEvda(dir);
-  const plist = launchdPlist(key, dir, { home });
+  const plist = launchdPlist(key, dir, { home, claude });
   mkdirSync(agentsDir, { recursive: true });
-  mkdirSync(join(home, "Library", "Logs", "evda"), { recursive: true });
-  const path = join(agentsDir, `${label(key, evda)}.plist`);
+  const name = label(key, evda);
+  const path = join(agentsDir, `${name}.plist`);
   const existed = existsSync(path);
   writeFileSync(path, plist);
   let loaded = "not loaded (EVDA_NO_LAUNCHCTL=1)";
   if (load) {
-    const uid = process.getuid?.() ?? "";
-    spawnSync("launchctl", ["bootout", `gui/${uid}`, path], { encoding: "utf8" });
-    const r = spawnSync("launchctl", ["bootstrap", `gui/${uid}`, path], { encoding: "utf8" });
+    // The log folder is made only for a job that is loaded, so an unloaded install writes nothing
+    // into the owner's home but the job file.
+    mkdirSync(join(home, "Library", "Logs", "evda"), { recursive: true });
+    const domain = `gui/${process.getuid?.() ?? ""}`;
+    bootout(`${domain}/${name}`, env, launchctl);
+    const r = launchctl(["bootstrap", domain, path]);
     loaded = r.status === 0 ? "loaded" : `launchctl bootstrap exited ${r.status}: ${(r.stderr ?? "").trim()}`;
   }
-  return { path, existed, loaded };
+  return { path, label: name, existed, loaded, claude };
+}
+
+// Turn a routine off: unload the job, remove its file, then look again. `off` is true only when
+// launchd has no job under the label and the file is gone; anything left is named in `left`.
+// Nothing there at all is not an error.
+export function uninstallLaunchd(key, dir, { env = process.env, home = env.HOME ?? homedir(), agentsDir = env.EVDA_LAUNCH_AGENTS ?? process.env.EVDA_LAUNCH_AGENTS ?? join(home, "Library", "LaunchAgents"), load = !noLaunchctl(env), launchctl = (a) => runLaunchctl(a, env) } = {}) {
+  const name = label(key, openEvda(dir));
+  const path = join(agentsDir, `${name}.plist`);
+  const target = `gui/${process.getuid?.() ?? ""}/${name}`;
+  const hadFile = existsSync(path);
+  const wasLoaded = load && isLoaded(target, launchctl);
+  if (!hadFile && !wasLoaded) return { path, label: name, removed: false, off: true, left: [] };
+  if (wasLoaded) bootout(target, env, launchctl);
+  rmSync(path, { force: true });
+  const left = [];
+  if (load && isLoaded(target, launchctl)) left.push(`launchd still has ${name} loaded (remove it: launchctl bootout ${target})`);
+  if (existsSync(path)) left.push(`the job file is still at ${path}`);
+  return { path, label: name, removed: true, off: left.length === 0, left };
+}
+
+// What setup does with the routines it was given (HQ-1246). On a Mac each is installed as a launchd
+// job; elsewhere nothing can be scheduled from here, so it prints the Claude desktop steps and says
+// so. Returns the lines to print.
+export function installAtSetup(keys, dir, { env = process.env, platform = process.platform } = {}) {
+  const lines = [];
+  for (const key of keys) {
+    const r = ROUTINES[key];
+    lines.push("");
+    if (platform === "darwin") {
+      const done = installLaunchd(key, dir, { env });
+      const lead = key === "morning" ? "Organizing is on" : `${r.title} is on`;
+      lines.push(`${lead}: ${r.when.toLowerCase()} your own Claude ${key === "morning" ? "files your notes into their day and writes what belongs where" : "reads your week back to you"}, in reports/. Turn it off: evda routine ${key} ${resolve(dir)} --uninstall`);
+      lines.push(`  launchd job ${done.path}: ${done.loaded}. It runs while this computer is on; asleep at that hour, it runs when it wakes.`);
+      if (!done.claude) lines.push("  Claude Code was not found on this computer, so the filing runs and the report says the AI part did not. Install Claude Code and sign in to add it.");
+    } else {
+      for (const l of desktopInstructions(key, dir).split("\n")) lines.push(l);
+      lines.push("Nothing was scheduled on this computer: add the routine above in the Claude desktop app.");
+    }
+  }
+  const where = keys.length && platform === "darwin" ? protectedLocation(dir, env) : null;
+  if (where) lines.push(`This record is in ${where}. A scheduled run cannot read it there unless the shell has Full Disk Access (System Settings, Privacy & Security, Full Disk Access), or move the record to a folder of its own.`);
+  return lines;
 }
 
 export function routineMain(args, { pickDir }) {
   const key = args[0];
-  if (!ROUTINE_KEYS.includes(key)) throw new EvdaError(`usage: evda routine <${ROUTINE_KEYS.join("|")}> [dir] [--launchd] [--install]`, { exit: 2 });
+  if (!ROUTINE_KEYS.includes(key)) throw new EvdaError(`usage: evda routine <${ROUTINE_KEYS.join("|")}> [dir] [--launchd] [--install] [--uninstall]`, { exit: 2 });
   const { dir, flags } = pickDir(args.slice(1));
+  if (flags.includes("--uninstall")) {
+    const r = uninstallLaunchd(key, dir);
+    if (!r.removed) {
+      console.log(`nothing to remove: no ${ROUTINES[key].id} job at ${r.path}`);
+      return 0;
+    }
+    const what = key === "morning" ? "organizing" : ROUTINES[key].title;
+    if (!r.off) {
+      console.log(`${what} is not off: ${r.left.join("; ")}.`);
+      return 1;
+    }
+    console.log(`removed ${r.path}: ${what} is off. Turn it back on: evda routine ${key} ${resolve(dir)} --install`);
+    return 0;
+  }
   if (flags.includes("--install")) {
     const r = installLaunchd(key, dir);
     console.log(`${r.existed ? "replaced" : "wrote"} ${r.path}: ${r.loaded}. ${ROUTINES[key].when}, it runs: ${routineCommand(key, dir)}`);

package/lib/setup.mjs

@@ -283,7 +283,7 @@ export function questions(agent = DEFAULT_AGENT_NAME) {
     { key: "filing", text: `Should ${agent} file everything you say automatically, or only when you ask? (everything)` },
     { key: "import", text: "Bring in what your AI already knows about you?" },
     { key: "skill", text: `Install the evda skill for Claude Code, so ${agent} works through your EVÐA from any folder?` },
-    { key: "morning", text: "Add a morning organize routine, which files your captures into their day and reports what belongs where?" },
+    { key: "morning", text: "Organizing is on: each morning your own Claude files your notes into their day and writes what belongs where. Keep it on?" },
     { key: "weekly", text: "Add a weekly look back routine, which reads your week back to you?" },
   ];
 }
@@ -397,9 +397,52 @@ export async function interview(opts, io, { presets = [] } = {}) {
   }
   if (a.routines == null) {
     out("");
-    out("Routines are optional and nothing is scheduled without a yes. Each runs through your own AI, never an API key in EVÐA.");
-    a.routines = [];
-    for (const key of ["morning", "weekly"]) if (await yes(key)) a.routines.push(key);
+    out("Routines run through your own AI, never an API key in EVÐA.");
+    // Organizing is on by default (HQ-1246): only an explicit no turns it off.
+    const keep = String(await ask(`${q("morning", agent)} (yes/no) `)).trim().toLowerCase();
+    a.routines = ["no", "n", "off"].includes(keep) ? [] : ["morning"];
+    if (await yes("weekly")) a.routines.push("weekly");
   }
   return a;
 }
+
+// ─── The parts a record starts with (HQ-1925) ────────────────────────
+//
+// Decided by the owner: privacy is set per folder when the record is made, everything is
+// accessible by default, and the AI reads on request. So a new record is split into two parts on
+// day one, and a phone can be added with no terminal step:
+//   journal  the day files and captures, wherever the manifest maps them
+//   private  the record root: everything else, including any folder made later
+// The computer holds both as owner. A phone is offered the journal and nothing else.
+// Pure, like the rest of this file, so the app's window reads the same words; circle-plan.mjs
+// `defaultParts` writes the plan.
+
+export const JOURNAL_PART = "journal";
+export const PRIVATE_PART = "private";
+/** What Add a phone offers a phone. */
+export const PHONE_PARTS = [JOURNAL_PART];
+/** The roles whose folders are the journal. */
+const JOURNAL_ROLES = ["record/daily", "record/captures"];
+
+/** The circle plan for a record's default parts, from its manifest mapping and its id. */
+export function defaultPartsPlan(mapping = {}, recordId) {
+  const roots = [...new Set(JOURNAL_ROLES.map((r) => mapping[r]).filter((p) => typeof p === "string").map((p) => p.replace(/^\/+|\/+$/g, "")).filter(Boolean))];
+  // Each starts with an empty policy: the owner's corrections about a part land there.
+  const circles = roots.length ? [{ name: JOURNAL_PART, roots, policy: [] }] : [];
+  circles.push({ name: PRIVATE_PART, roots: [""], policy: [] });
+  return { circles, devices: { computer: { atlasId: recordId, grants: { "*": "owner" } } } };
+}
+
+/** One line for create-evda's report. */
+export const PARTS_LINE = "parts: journal (your daily pages and captures) and private (everything else). A phone you add gets the journal.";
+
+/** What the app shows when an adopted record has no parts, and the one button that splits it. */
+export const PARTS_OFFER = {
+  title: "Your EVÐA is not split into parts yet",
+  lines: [
+    "A phone only gets the parts of your EVÐA you give it, so this Mac needs to know which part is your journal.",
+    "This makes two parts. Journal is your daily pages and captures, and it is what a phone gets. Private is everything else, and it stays on this Mac.",
+    "Nothing in your files moves or changes, and nothing reaches a phone until you add one.",
+  ],
+  button: "Split it into journal and private",
+};

package/lib/sync-rules.mjs

@@ -7,9 +7,10 @@
 //
 // Three kinds of thing never sync, and each is counted rather than dropped:
 //
-//   excluded      by name anywhere (.DS_Store, node_modules, .git), by name at the root (.evda, the
-//                 derived index every device rebuilds), or by a path the plan names. Reported as
-//                 EXCLUDED n.
+//   excluded      by name anywhere (.DS_Store, node_modules, .git), by name prefix anywhere (~$, the
+//                 owner file Word, Excel and PowerPoint keep beside a document while it is open), by
+//                 name at the root (.evda, the derived index every device rebuilds), or by a path the
+//                 plan names. Reported as EXCLUDED n.
 //   symlink       never followed and never carried: sync moves bytes, and a link's target may be
 //                 outside the record, missing, or itself. A symlink inside a circle fails the
 //                 coverage check until the plan excludes it.
@@ -24,6 +25,11 @@ import { lstatSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 
 export const EXCLUDE_NAMES = [".DS_Store", "node_modules", ".git", ".Trash", "Icon\r"];
+// A name starting with one of these is one machine's state about a file, not the record. `~$` is
+// the Office owner file: it exists only while a document is open on that machine, and iCloud never
+// carries one, so a shadow fed by the laptop held one Hestia's record could not (HQ-1219,
+// 2026-09-25, `~$e Lantern Version 3.docx`, EXTRA).
+export const EXCLUDE_PREFIXES = ["~$"];
 export const EXCLUDE_ROOT_NAMES = [".evda"];
 // The relay refuses a blob over 64 MiB (`xania-relay/src/relay.mjs`, MAX_BLOB_BYTES); the seal adds
 // a nonce, a tag and an ephemeral key, so leave a margin.
@@ -40,7 +46,7 @@ export function excluder(extra = []) {
   const paths = extra.map(norm).filter((p) => p !== "");
   return (rel) => {
     const parts = norm(rel).split("/");
-    if (parts.some((p) => EXCLUDE_NAMES.includes(p))) return true;
+    if (parts.some((p) => EXCLUDE_NAMES.includes(p) || EXCLUDE_PREFIXES.some((x) => p.startsWith(x)))) return true;
     if (EXCLUDE_ROOT_NAMES.includes(parts[0])) return true;
     const r = parts.join("/");
     return paths.some((p) => r === p || r.startsWith(`${p}/`));

package/lib/tools.mjs

@@ -35,6 +35,7 @@ import { doctor } from "./doctor.mjs";
 import { readContext, mayRead, heldBack, callerFrom, aiView, note as writeNote, releaseNote, SEALED_WHY } from "./readers.mjs";
 import { EvdaError } from "./errors.mjs";
 import { dayRole, appendToDay, CONTEXT_LABEL, localDate, localTime } from "./day-file.mjs";
+import { writeMessage, unseenReplies } from "./messages.mjs";
 
 export { localDate, localTime, CONTEXT_LABEL };
 
@@ -296,6 +297,20 @@ export function releaseTool(evda, args = {}, { now = new Date() } = {}) {
   return releaseNote(evda, args.path, { now });
 }
 
+// 5d. Tell the owner something (HQ-1246): one new message file under the messages role, which the
+// phone app shows as a card. Never edits one; refuses anything secret-shaped, like every write.
+export function message(evda, args = {}, { now = new Date() } = {}) {
+  onlyKeys("evda_message", args, ["title", "body", "from"], "It writes one new message for the owner and nothing else: it takes no path, and it never edits a message once written.");
+  return writeMessage(evda, args, { now, refuseSecrets });
+}
+
+// 5e. The owner's replies to messages, the ones not seen yet, marked seen unless peek is true.
+export function replies(evda, args = {}, { caller = callerFrom() } = {}) {
+  onlyKeys("evda_replies", args, ["peek"]);
+  if (args.peek !== undefined && typeof args.peek !== "boolean") throw new EvdaError("evda_replies peek is true or false.", { code: "BAD_ARGUMENT", exit: 2 });
+  return unseenReplies(evda, { peek: args.peek === true }, { caller });
+}
+
 // 6. Circles and their policies, as the record declares them. Read only.
 export function circles(evda, args = {}) {
   onlyKeys("evda_circles", args, []);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-evda",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "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": {
@@ -12,22 +12,25 @@
   },
   "scripts": {
     "test": "node --test test/*.test.mjs",
-    "lint": "node scripts/dashes-check.mjs && node scripts/build-templates.mjs --check && node scripts/build-kinds.mjs --check",
+    "lint": "node scripts/dashes-check.mjs && node scripts/build-templates.mjs --check && node scripts/build-kinds.mjs --check && node scripts/check-installed-core.mjs",
     "templates:build": "node scripts/build-templates.mjs",
     "templates:check": "node scripts/build-templates.mjs --check",
+    "installed-core:check": "node scripts/check-installed-core.mjs",
     "kinds:build": "node scripts/build-kinds.mjs",
     "kinds:check": "node scripts/build-kinds.mjs --check",
     "dashes:check": "node scripts/dashes-check.mjs",
     "vectors:both": "bash scripts/vectors-both.sh",
     "doctor": "node bin/evda.mjs doctor",
     "publish:dry": "node scripts/publish.mjs",
-    "publish:live": "node scripts/publish.mjs --publish"
+    "publish:live": "node scripts/publish.mjs --publish",
+    "pairing:build": "node scripts/build-pairing.mjs"
   },
   "files": [
     "bin",
     "hooks",
     "docs",
     "lib",
+    "dist",
     "templates",
     "skills",
     "migrations",

package/skills/evda/SKILL.md

@@ -20,8 +20,7 @@ calls no model; you are their own AI, and everything you keep goes through the t
    Say nothing if it is current or was skipped. If an update is available or the check failed, say
    the one line it returns, briefly, and hand them the command it names to run in a terminal. The
    tool only tells: nothing in this server installs an update. It asks the npm registry for a
-   version number and sends nothing from the record, and it is the only tool here that reaches the
-   network at all. `evda check-update` is the same check from a shell, for a session that has one.
+   version number and sends nothing from the record. `evda check-update` is the same check from a shell, for a session that has one.
 
 If the tools are not there, say so plainly and point them at `evda connect`, which prints the
 setup for each client. Do not keep the record some other way.
@@ -128,16 +127,17 @@ move). Tell them what it placed, what it left for them, and the reversal manifes
 file of its date and writes a report under `reports/organize/`. With `--with-ai` it then asks you,
 through `claude -p`, for the part that needs judgment, and appends your answer to that report.
 
-When you are asked for that judgment:
+When you are asked for that judgment, you are given their entries from the last two weeks, each
+under its date. Hand back one thing that comes back across different days, in their own words:
 
-1. Read the report you are given, then use the read tools (`evda_recent`, `evda_search`,
-   `evda_circles`) to check each item against the record.
-2. For each note that needs a place, answer in one line: the note's path, where it belongs (a
-   person's file, a project, the ledger only if they already agreed to it), and the words from the
-   note that say so, quoted.
+1. One or two plain sentences naming what comes back, then each place it came from as
+   `- YYYY-MM-DD: "words copied exactly from that day"`, from two days or more. A quote that is not
+   in the entry of its date drops the whole answer, so copy, never paraphrase.
+2. Say only what the entries say: no advice, no question back, no score, no count, and nothing about
+   filing, the report or yourself. The filing is already listed above your answer.
 3. You write nothing yourself here. Move nothing, rename nothing, delete nothing, and never touch
-   `circles/` or `grants/`. The owner reads the report and decides.
-4. If nothing needs a place, say that in one line.
+   `circles/` or `grants/`.
+4. If nothing honestly comes back across two days, answer `NOTHING`; the report then says nothing.
 
 ## Look back (weekly)
 

package/templates/AGENTS.md

@@ -161,6 +161,10 @@ They are mechanisms, never rules about their life.
 - **A goal that was never theirs does close to nothing when reached.** Whose goal it was matters more
   than reaching it. When hard work toward something returns nothing, ask where the goal came from, not
   about effort or strategy.
+- **A view is built for a self who will not stay.** People expect to change less than they do, so a
+  conclusion about their life is fitted to a person who will not be there in ten years. Asking what the
+  view assumes stays fixed, and what happens if it does not, finds where it breaks. Some futures change
+  the one who would judge them, and no thinking settles those in advance.
 - **Most of the good you do comes from making them get specific.** A vague claim about their life,
   negative or positive, shapes how they think, and having to say exactly what they mean is what moves
   them. So go for insight, not more reflection: going over a feeling without getting anywhere new

package/templates/evda-digest.md

@@ -23,6 +23,7 @@ Instruction-only digest of the generated block of AGENTS.md. Read AGENTS.md in f
 - A want can be sincerely felt and still not be theirs
 - Getting the thing under-delivers, for two reasons
 - A goal that was never theirs does close to nothing when reached
+- A view is built for a self who will not stay
 - Most of the good you do comes from making them get specific
 ## Meet them where they are
 ## From recognition to action