create-evda 0.1.8 → 0.1.9

package/CHANGELOG.md

@@ -4,15 +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 pair a phone (`evda_pair_device`). Pairing goes
+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,9 +92,12 @@ 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_pair_device       a one-time code and QR link for your phone, and what to do on it; the phone gets only the parts named
+    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 and what each reads
+    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. 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:
@@ -103,6 +107,8 @@ claude mcp add --scope user evda -- /path/to/node /path/to/evda.mjs mcp ~/my-evd
 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

@@ -34,8 +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.
 
@@ -101,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]
@@ -116,11 +121,24 @@ const HELP = `evda: operate an EVDA. The files are the truth; this is optional.
   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
@@ -154,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
@@ -185,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", "parts", "relay"];
+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);
@@ -272,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": {
@@ -369,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");
@@ -507,6 +550,12 @@ async function main(argv) {
 
     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 }));
@@ -514,6 +563,16 @@ async function main(argv) {
       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);
@@ -527,6 +586,24 @@ async function main(argv) {
       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.
@@ -572,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;
     }
 
@@ -588,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);
@@ -607,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);
@@ -963,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

@@ -33,6 +33,7 @@ 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";
@@ -332,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("");