create-evda 0.1.1 → 0.1.3

package/README.md

@@ -1,41 +1,74 @@
-# @evda/person-record
+# create-evda
 
-The person layer over the substrate. An EVÐA is a directory that knows what it is: a person's record in their own words, a ledger of claims about them and what happened to each claim, and the operating instructions beside them, so that any agent on any model can open it and act correctly with no outside context.
+EVÐA is a really organized journal that helps you live your life the more you use it. Use it on every part of your life: what stresses you out, what you are uncertain of, the things you do every day that feel slightly off. Freewrite with Iris, and you get better at seeing your thoughts, understanding why you do what you do, why certain people matter to you and why you react the way you do.
 
-This package scaffolds one and ships the optional tooling. The files are the truth. Nothing here is required to read or write a record; `evda doctor` says whether one is well-formed and `evda reindex` rebuilds the derived directory, and both can be thrown away. It has no runtime dependencies (`test/deps.test.mjs` asserts it) and never makes a network call.
+Iris cannot give you the right answer for your life, but it is really good at suggestions. Take them, push back on what you disagree with, get specific, and get a new response back. Iris keeps your words in your EVÐA as you talk. EVÐA is not a tool to do what you already do a little better: it helps you learn what is worth doing, do that better, revise, and continue. We assume far more about ourselves, our situations and other people than we know, and you learn to be specific about those assumptions.
 
-Design contract: Spec 04 (the hypothesis ledger), Spec 05 (the data layer) and Spec 07 (holders, circles, references and views) in the EVÐA project. A short copy of what this package settles is in `docs/canon/person-record.md`.
+It is not easy to write down thoughts you have not admitted to yourself, never mind to a friend or a therapist. EVÐA is designed for exactly that, and it is open source to lower that barrier as far as it goes. Your record is plain files on your own machine and it is never accessible to anyone at EVÐA: the company never receives it. The AI you choose does receive what Iris reads, which is why setup has you turn model training off first. Capable open source models you run on your own hardware are the next step, so you know exactly where your words go.
 
-## Where it sits
+EVÐA prescribes no values and no rules. The only requirement is that you want to, and you are open to it. It is built on a neo-Aristotelian philosophy; ask your agent about it, or have any agent verify it by reading this code.
 
-Block tier, domain neutral. It imports nothing from the workspace at runtime. What it shares with the substrate is a file format: a circle is an eco, declared by the same `eco.yaml` that `@evda/common` parses and `@evda/vault-core` stores, and `test/eco-parity.test.mjs` runs every manifest this package writes through the substrate's own parser. Grants, entity addressing, changes and sync stay the substrate's; this package reads and writes plain files and leaves those to it.
+```bash
+npx create-evda my-evda
+```
 
-## Scaffold
+## Setup
+
+On a terminal, `create-evda` asks one question at a time: what to call your agent (Iris unless you rename it), who you are, what you want this for, how it should talk to you, and which AI you will use. It shows where that AI's training setting is, links the provider's own page, and does not finish until you type yes. The answers go into "What this EVÐA is" at the top of `AGENTS.md`, in your words. It suggests dictation: Apple's built in dictation, or Wispr Flow with data collection turned off. Last, it offers to bring in what an AI you already use knows about you; see below.
+
+Unattended, nothing is asked:
 
 ```bash
-node create-evda.mjs my-evda --owner "Dana"
+npx create-evda my-evda --yes --agent-name Iris --owner "Dana" --purpose "why work stresses me out" \
+  --voice "direct" --platform claude --training-off
 ```
 
+`--platform` takes `claude`, `chatgpt` (ChatGPT and Codex), `gemini`, `cursor` or `other`. Without `--training-off` the AI line stays empty and the agent asks about training in the first session. A run with no terminal on stdin is treated as `--yes`.
+
+## Any AI
+
+`AGENTS.md` is the one source. Codex, Cursor, GitHub Copilot, Windsurf, Zed, opencode and the other tools on agents.md read it directly. For the two that do not, the scaffold writes a one line loader: `CLAUDE.md` for Claude Code and `GEMINI.md` for Gemini CLI, each `@AGENTS.md`. Aider takes `aider --read AGENTS.md`. The Claude desktop app reads it too, once its Filesystem extension is installed and pointed at this folder (Settings, then Extensions, then Filesystem). ChatGPT and Claude in the browser or app, used through a Project, cannot read or write this folder: a Project's instructions field holds text for that conversation only, and pasting `AGENTS.md` into it does not run an EVDA, because nothing you write there reaches `record/`. Bring what a chat app like that already knows about you in once, as an import, instead: see "Bringing in what an AI already knows" below.
+
+## Bringing in what an AI already knows
+
+Setup ends by asking whether to bring in what an AI you already talk to knows about you. Say yes and it prints a prompt: paste that into ChatGPT, Claude, or whatever you use, and it writes out what it remembers or has guessed about you, in plain text. Bring the answer to your first session and your agent files it verbatim under `record/imports/YYYY-MM-DD-<source>.md`, with the source and date at the top. It is filed as what that AI said, never as your own words, and every line in it is a claim to check with you over time, not a fact.
+
+## Circles and other people
+
+Everything is private until you share it. A circle is a part of the record you choose to share, plus who may read it. Audience and content are set separately: a public circle has the widest audience and the least content. Ask the agent to share something and it proposes a circle with a plain policy and waits for your yes; it never creates one, adds a reader, or moves an entry on its own. Another person reads a circle through a grant naming their own record (`evda grant family --to sam.atlas --kind person`), and `evda revoke` takes it back. A part can be more private than its circle, never less.
+
+## The package
+
+`@evda/person-record` in this repository, published as `create-evda`. The person layer over the substrate. An EVÐA is a directory that knows what it is: a person's record in their own words, a ledger of reads about them held loosely, and the operating instructions beside them, so that any agent on any model can open it and act correctly with no outside context. The files are the truth. Nothing here is required to read or write a record; `evda doctor` says whether one is well formed and `evda reindex` rebuilds the derived directory, and both can be thrown away. It has no runtime dependencies (`test/deps.test.mjs` asserts it) and never makes a network call.
+
+Design contract: Spec 04 (the hypothesis ledger), Spec 05 (the data layer), Spec 06 (the guarantee) and Spec 07 (holders, circles, references and views) in the EVÐA project. A short copy of what this package settles is in `docs/canon/person-record.md`.
+
+## Where it sits
+
+Block tier, domain neutral. It imports nothing from the workspace at runtime. What it shares with the substrate is a file format: a circle is an eco, declared by the same `eco.yaml` that `@evda/common` parses and `@evda/vault-core` stores, and `test/eco-parity.test.mjs` runs every manifest this package writes through the substrate's own parser. Grants, entity addressing, changes and sync stay the substrate's; this package reads and writes plain files and leaves those to it.
+
+## Scaffold
+
 Writes:
 
     my-evda/
       evda.json              schema version, layers, and the MAPPING of roles to paths
-      README.md              what this is and how it works, for the owner, not the agent
+      README.md              what this is, how to turn training off, how circles work: for the owner
       AGENTS.md              the operating layer. One installer-owned fence; the rest is the owner's
-      CLAUDE.md              one line: @AGENTS.md (Claude Code does not read AGENTS.md on its own)
+      CLAUDE.md, GEMINI.md   one line each, @AGENTS.md, for Claude Code and Gemini CLI
       record/daily/          YYYY-MM-DD.md, verbatim. Day one holds one file: today's, recording
                              that the record was created. Everything after it is the owner's.
       record/captures/       each record folder carries folder.evda.json: what its entries are
       record/people/         (record, capture, person), which connectors feed its references,
                              and which views render it
-      ledger/hypotheses.md   the entry shape and the six rules are at the top of the file
+      ledger/hypotheses.md   the entry shape and the rules are at the top of the file
       circles/, grants/      with --layers record,ledger,circles: each circle's eco.yaml, and one
                              grant file per reader and circle
       .evda/version          the schema version actually on disk
       .evda/due.jsonl        derived from the ledger's Due lines
-      .evda/digest.md        derived from the fenced block of AGENTS.md, under 2048 bytes
+      .evda/digest.md        derived from the fenced block of AGENTS.md, under 4096 bytes
 
-Then open the directory in Claude Code, or any agent that reads AGENTS.md, and say something true about today. It goes into `record/daily/` in your words. Nothing is proposed about you until the record holds something to be wrong about.
+The training instructions in the scaffolded README and in setup come from one table, `lib/setup.mjs`, with a link to each provider's page.
 
 The tree above is what the scaffolder creates and not a requirement. `evda.json` carries a `mapping` from roles to paths, and every tool reads roles. An existing folder of notes becomes an EVÐA by adding `evda.json` with a mapping that names where things already are, and nothing moves.
 
@@ -196,7 +229,7 @@ Nothing in this package belongs to one person's record. Two things that do are r
 ## Checks
 
 ```bash
-pnpm --filter @evda/person-record test          # node --test, 101 tests
+pnpm --filter @evda/person-record test          # node --test
 pnpm --filter @evda/person-record lint          # no em or en dashes; generated templates match the spec when reachable
 pnpm --filter @evda/person-record vectors:both  # both readers over every vector; SKIPPED for the one not reachable
 ```
@@ -205,4 +238,4 @@ The package tests need `@evda/common` built first (`pnpm --filter @evda/common..
 
 ## Publishing
 
-Not published. The bins are `create-evda` and `evda`; a public package under the `create-evda` name so that `npx create-evda my-evda` works is the owner's decision and its own ticket.
+Published to npm as `create-evda`, with the bins `create-evda` and `evda`. This directory is `@evda/person-record` in the workspace; the npm copy is staged from it with the same runtime files, the LICENSE, and no devDependencies.

package/bin/evda.mjs

@@ -51,7 +51,9 @@ const HELP = `evda: operate an EVDA. The files are the truth; this is optional.
   evda status [dir]              one screen summary
   evda where                     which EVDA the locator resolves to, and by which rule
   evda use <dir>                 point ~/.evda/current at a record
-  evda init <dir> [--name N] [--owner O] [--layers record,ledger]
+  evda init <dir> [--yes] [--agent-name N] [--owner O] [--purpose P] [--voice V]
+                [--platform claude|chatgpt|gemini|cursor|other] [--training-off] [--layers record,ledger]
+                                 the same as create-evda: asks on a terminal, runs from flags otherwise
 
 Locator order: directory argument, $EVDA_HOME, the working directory's ancestors, ~/.evda/current.
 Exit codes: 0 ok, 1 the record has a problem and it was named, 2 refused (nothing written).`;

package/create-evda.mjs

@@ -1,14 +1,21 @@
 #!/usr/bin/env node
 // create-evda: scaffold an EVDA, a directory that knows what it is.
 //
-//   node create-evda.mjs <dir> [--name NAME] [--owner NAME] [--layers record,ledger[,circles]] [--force]
+//   create-evda <dir> [--agent-name NAME] [--owner NAME] [--purpose TEXT] [--voice TEXT]
+//                     [--platform claude|chatgpt|gemini|cursor|other] [--training-off] [--yes]
+//                     [--name NAME] [--layers record,ledger[,circles]] [--force]
 //
-// Writes the manifest, the operating layer, the corpus, the ledger with its own entry shape at the
-// top, and .evda/. Then runs `evda doctor` on what it wrote and prints the one instruction that
-// matters. It creates no example notes: an empty record that fills with a real life is the
-// product, and one seeded with fake content teaches the owner to ignore it. The one file it writes
-// under record/ is today's daily file holding a true event, the record's own creation, so that the
-// first session has something dated to read and the owner sees where their words go.
+// On a terminal, any setup answer not given as a flag is asked, one question at a time, and setup
+// does not finish until the owner confirms model training is off for the AI they chose. With
+// --yes, or with no terminal, nothing is asked: the flags are written as given, and the AI line
+// stays empty unless --training-off was passed, so the agent asks in the first session.
+//
+// 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
+// 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.
 
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join, resolve, dirname } from "node:path";
@@ -21,6 +28,7 @@ import { doctor } from "./lib/doctor.mjs";
 import { readPointer, setPointer, pointerPath } from "./lib/locate.mjs";
 import { FOLDER_MANIFEST } from "./lib/folders.mjs";
 import { EvdaError } from "./lib/errors.mjs";
+import { PLATFORMS, PLATFORM_KEYS, LOADERS, DESKTOP_FILESYSTEM, DICTATION, DEFAULT_AGENT_NAME, platformKey, fillOwnerSection, aiLine, interview, trainingSection } from "./lib/setup.mjs";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const TEMPLATES = join(HERE, "templates");
@@ -46,24 +54,48 @@ const FOLDER_TYPES = {
   "record/people": "person",
 };
 
-function parseArgs(argv) {
-  const opts = { layers: ["record", "ledger"], force: false, name: null, owner: "", kind: "person", id: null, pointer: true, use: false };
+const USAGE = `usage: create-evda <dir> [--agent-name NAME] [--owner NAME] [--purpose TEXT] [--voice TEXT] [--platform ${PLATFORM_KEYS.join("|")}] [--training-off] [--yes] [--name NAME] [--kind person|agent|company] [--id ATLAS-ID] [--layers record,ledger] [--use] [--no-pointer]`;
+
+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,
+  };
+  const args = argv.flatMap((a) => {
+    const eq = /^(--[a-z-]+)=([\s\S]*)$/.exec(a);
+    return eq ? [eq[1], eq[2]] : [a];
+  });
   const positional = [];
-  for (let i = 0; i < argv.length; i++) {
-    const a = argv[i];
+  const value = (i, flag) => {
+    if (i >= args.length) throw new EvdaError(`${flag} needs a value`, { exit: 2 });
+    return args[i];
+  };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
     if (a === "--force") opts.force = true;
     else if (a === "--no-pointer") opts.pointer = false;
     else if (a === "--use") opts.use = true;
-    else if (a === "--name") opts.name = argv[++i];
-    else if (a === "--owner") opts.owner = argv[++i] ?? "";
-    else if (a === "--kind") opts.kind = argv[++i];
-    else if (a === "--id") opts.id = argv[++i];
-    else if (a === "--layers") opts.layers = (argv[++i] ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+    else if (a === "--yes" || a === "-y") opts.yes = true;
+    else if (a === "--training-off") opts.trainingOff = true;
+    else if (a === "--name") opts.name = value(++i, a);
+    else if (a === "--owner") opts.owner = value(++i, a);
+    else if (a === "--agent-name") opts.agentName = value(++i, a);
+    else if (a === "--purpose") opts.purpose = value(++i, a);
+    else if (a === "--voice") opts.voice = value(++i, a);
+    else if (a === "--platform") {
+      const raw = value(++i, a);
+      opts.platform = platformKey(raw);
+      if (!opts.platform) throw new EvdaError(`--platform needs one of ${PLATFORM_KEYS.join(", ")}, or the name of your AI`, { exit: 2 });
+      if (opts.platform === "other" && raw.trim().toLowerCase() !== "other") opts.platformName = raw.trim();
+    }
+    else if (a === "--kind") opts.kind = value(++i, a);
+    else if (a === "--id") opts.id = value(++i, a);
+    else if (a === "--layers") opts.layers = value(++i, a).split(",").map((s) => s.trim()).filter(Boolean);
     else if (a === "--quiet") opts.quiet = true;
     else if (a.startsWith("--")) throw new EvdaError(`unknown option ${a}`, { exit: 2 });
     else positional.push(a);
   }
-  if (positional.length !== 1) throw new EvdaError("usage: create-evda <dir> [--name NAME] [--owner NAME] [--kind person|agent|company] [--id ATLAS-ID] [--layers record,ledger] [--use] [--no-pointer]", { exit: 2 });
+  if (positional.length !== 1) throw new EvdaError(USAGE, { exit: 2 });
   opts.dir = resolve(positional[0]);
   if (!opts.name) opts.name = opts.dir.split("/").pop();
   for (const l of opts.layers) if (!KNOWN_LAYERS.includes(l)) throw new EvdaError(`unknown layer "${l}". Known: ${KNOWN_LAYERS.join(", ")}`, { exit: 2 });
@@ -77,11 +109,15 @@ function render(name, vars) {
   return text;
 }
 
-export function scaffold(opts) {
-  const { dir } = opts;
-  if (existsSync(dir) && readdirSync(dir).length > 0 && !opts.force) {
+function refuseNonEmpty(dir, force) {
+  if (existsSync(dir) && readdirSync(dir).length > 0 && !force) {
     throw new EvdaError(`REFUSED: ${dir} exists and is not empty. Nothing was written. Pass --force to scaffold into it anyway (existing files are never overwritten).`, { exit: 2 });
   }
+}
+
+export function scaffold(opts) {
+  const { dir } = opts;
+  refuseNonEmpty(dir, opts.force);
   const today = localDate();
   const mapping = { agents: CANONICAL.agents };
   for (const layer of opts.layers) for (const role of rolesForLayer(layer)) mapping[role] = CANONICAL[role];
@@ -95,11 +131,20 @@ export function scaffold(opts) {
   const id = opts.id ?? `${slug(opts.name)}.atlas`;
   const problems = holderProblems({ owner: { kind }, id });
   if (problems.length) throw new EvdaError(`REFUSED: ${problems.join(" ")}`, { exit: 2 });
-  const manifest = { evda: SCHEMA_VERSION, id, name: opts.name, owner: { name: opts.owner, kind }, created: today, layers: opts.layers, mapping };
+  const manifest = { evda: SCHEMA_VERSION, id, name: opts.name, owner: { name: opts.owner ?? "", kind }, created: today, layers: opts.layers, mapping };
   writeIfAbsent(join(dir, "evda.json"), JSON.stringify(manifest, null, 2) + "\n");
-  writeIfAbsent(join(dir, "README.md"), render("README.md", {}));
-  writeIfAbsent(join(dir, mapping.agents), render("AGENTS.md", {}));
-  writeIfAbsent(join(dir, "CLAUDE.md"), render("CLAUDE.md", { agents: mapping.agents }));
+  writeIfAbsent(join(dir, "README.md"), render("README.md", { training: trainingSection() }));
+  // The owner section of AGENTS.md holds the setup answers in the owner's words. The AI line is
+  // written only when training off was confirmed; empty, it is what makes the agent ask.
+  const answers = {
+    agentName: opts.agentName,
+    owner: opts.owner,
+    purpose: opts.purpose,
+    voice: opts.voice,
+    ai: aiLine({ platform: opts.platform, platformName: opts.platformName, trainingOff: opts.trainingOff, date: today }),
+  };
+  writeIfAbsent(join(dir, mapping.agents), fillOwnerSection(render("AGENTS.md", {}), answers));
+  for (const loader of Object.keys(LOADERS)) writeIfAbsent(join(dir, loader), render(loader, { agents: mapping.agents }));
   if (mapping.ledger) writeIfAbsent(join(dir, mapping.ledger, "hypotheses.md"), render("hypotheses.md", { date: today, name: opts.name }));
   if (mapping["record/daily"]) writeIfAbsent(join(dir, mapping["record/daily"], `${today}.md`), firstDay(today));
   if (mapping.circles) writeIfAbsent(join(dir, mapping.circles, "README.md"), render("circles-README.md", {}));
@@ -154,10 +199,37 @@ function writeIfAbsent(path, text) {
   writeFileSync(path, text);
 }
 
-export async function main(argv) {
-  const opts = parseArgs(argv);
+// The terminal the setup questions go to.
+async function terminalIO() {
+  const { createInterface } = await import("node:readline/promises");
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return { interactive: true, ask: (q) => rl.question(q), out: (l) => console.log(l), close: () => rl.close() };
+}
+
+export function needsAsking(opts) {
+  return opts.agentName == null || !opts.owner || !opts.purpose || !opts.voice || !opts.platform || !opts.trainingOff;
+}
+
+// `io` is for tests: { interactive, ask(question), out(line) }. Without it, setup is interactive
+// only when both stdin and stdout are a terminal. A piped or redirected run is a script, and a
+// script is never asked anything.
+export async function main(argv, io = null) {
+  let opts = parseArgs(argv);
+  const out = io?.out ?? console.log;
+  const log = opts.quiet ? () => {} : out;
+  const tty = io ? Boolean(io.interactive) : Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const asked = tty && !opts.yes && needsAsking(opts);
+  if (asked) {
+    refuseNonEmpty(opts.dir, opts.force);
+    const term = io ?? (await terminalIO());
+    try {
+      opts = await interview(opts, term);
+    } finally {
+      term.close?.();
+    }
+    log("");
+  }
   const { dir, pointer } = scaffold(opts);
-  const log = opts.quiet ? () => {} : console.log;
   log(`created an EVDA at ${dir}`);
   log(`locator ${pointer.path}: ${pointer.action}\n`);
   const report = doctor(dir, { out: log, via: "create-evda" });
@@ -165,10 +237,21 @@ export async function main(argv) {
     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.");
     return report.exit;
   }
-  log(`\nOpen this directory in Claude Code, or any agent that reads AGENTS.md, and it will know what to do.`);
-  log(`It works from your words, takes a position instead of a menu, and parks what cannot be settled yet; it never scores you. Every correction becomes a rule, in your words, in a file you can open and edit. Pushing back is how you use it: it proposes a claim specific enough to be wrong, you say what is wrong, and the next one is sharper. README.md says this again at your own pace.`);
-  log(`First move: say something true about today. It goes into record/daily/${localDate()}.md in your words, and nothing is proposed about you until there is something there to be wrong about.`);
-  log(`The files are the record. \`evda doctor\` checks them and \`evda reindex\` rebuilds .evda/; neither is required.`);
+  const agent = opts.agentName || DEFAULT_AGENT_NAME;
+  const chosen = opts.platform ? [opts.platform] : PLATFORM_KEYS;
+  log("");
+  log(`Open it with ${agent}:`);
+  for (const k of chosen) for (const line of PLATFORMS[k].open) log(`  ${line}`);
+  if (opts.platform && opts.platform !== "other") log(`  ${PLATFORMS.other.open[0]}`);
+  for (const line of DESKTOP_FILESYSTEM) log(`  ${line}`);
+  if (!opts.trainingOff) {
+    log("");
+    log(`Model training is not confirmed off yet, so ${agent} asks about it first. Where to turn it off:`);
+    for (const k of chosen) log(`  ${PLATFORMS[k].label}: ${PLATFORMS[k].training[0]}${PLATFORMS[k].url ? ` ${PLATFORMS[k].url}` : ""}`);
+  }
+  log("");
+  log(`Then freewrite: what happened today, what is on your mind, what felt slightly off. Your words go into record/ as you talk. README.md says the rest.`);
+  if (!asked) log(DICTATION);
   return 0;
 }
 

package/lib/agents.mjs

@@ -16,7 +16,7 @@ import { EvdaError } from "./errors.mjs";
 
 export const FENCE_OPEN = "<!-- evda:generated -->";
 export const FENCE_CLOSE = "<!-- /evda:generated -->";
-export const DIGEST_BUDGET = 2048;
+export const DIGEST_BUDGET = 4096;
 export const TEMPLATE_PATH = join(dirname(fileURLToPath(import.meta.url)), "..", "templates", "AGENTS.md");
 
 // {before, generated, after} where generated INCLUDES both fence lines, or null if no fence.

package/lib/doctor.mjs

@@ -52,6 +52,7 @@ import { splitFence, digestFrom, digestBytes, DIGEST_BUDGET } from "./agents.mjs
 import { readCircles, coverage, LEGACY_MANIFEST } from "./circles.mjs";
 import { folderManifests, folderFor, viewNamedIn, FOLDER_MANIFEST } from "./folders.mjs";
 import { referencesIn } from "./references.mjs";
+import { KIND_FOR_TYPE, PERSON_KINDS, entryFromFile, readEntry } from "./kinds.mjs";
 import { EvdaError } from "./errors.mjs";
 
 // Same rule as record.mjs fileDate: a daily file is dated by a leading YYYY-MM-DD in its name.
@@ -156,7 +157,6 @@ export function doctor(dir, { out = console.log, via = "argument" } = {}) {
     if (agents.trim() === "") fail(rel, "is empty.");
     else {
       if (!/ledger/i.test(agents)) warn(rel, "never mentions the ledger. An operating layer that does not name the loop cannot operate it.");
-      if (!/hypothes/i.test(agents)) warn(rel, "never mentions hypotheses.");
       try {
         fence = splitFence(agents);
       } catch (e) {
@@ -357,6 +357,42 @@ export function doctor(dir, { out = console.log, via = "argument" } = {}) {
     }
     if (views === 0) skip("views", "no folder manifest declares a view");
     else ok(views, "views", `across ${folders.filter((f) => f.views.length).length} folder(s)`);
+
+    // 12c. typed entries (Spec 07, section 2): a folder whose manifest declares one of the six
+    // person-layer types holds entries of that kind. Each entry file (`.json`, `.yaml`, or markdown
+    // whose frontmatter says `kind:`) is read through lib/kinds.mjs: the SCHEMA's shape, then the
+    // kind's rules. A file of another kind, or one that does not read, fails with what is wrong.
+    // Markdown with no `kind:` is left alone; it is not claiming to be an entry.
+    const typed = folders.filter((f) => f.type && KIND_FOR_TYPE[f.type]);
+    if (typed.length === 0) {
+      skip("typed entries", `no folder manifest declares a person-layer type (${Object.keys(KIND_FOR_TYPE).join(", ")})`);
+    } else {
+      const owner = holder.id ?? holder.name;
+      const counts = {};
+      let entries = 0;
+      for (const f of typed) {
+        const want = KIND_FOR_TYPE[f.type];
+        const where = `folder ${relative(dir, f.dir) || "."}`;
+        const viewPaths = new Set(f.views.map((v) => resolve(dir, v.path)));
+        for (const p of filesUnder(f.dir)) {
+          if (folderFor(p, folders) !== f || viewPaths.has(p)) continue;
+          const name = p.slice(p.lastIndexOf(sep) + 1);
+          if (name === FOLDER_MANIFEST) continue;
+          const rel = relative(dir, p);
+          const read = entryFromFile(name, readFileSync(p, "utf8"));
+          if (read === null) 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; }
+          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;
+          for (const problem of readEntry(want, read.raw, { owner }).problems) fail(rel, `${want} ${problem}`);
+        }
+      }
+      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"}`);
+    }
   }
 
   // 13. references (Spec 07, section 4): a pointer, a label and a date, never the payload, never
@@ -406,6 +442,21 @@ export function doctor(dir, { out = console.log, via = "argument" } = {}) {
   }
 }
 
+// Every file under a directory, skipping dot entries, sorted, so a run lists the same order twice.
+function filesUnder(root) {
+  const out = [];
+  const walk = (d) => {
+    for (const name of readdirSync(d).sort()) {
+      if (name.startsWith(".")) continue;
+      const p = join(d, name);
+      if (statSync(p).isDirectory()) walk(p);
+      else out.push(p);
+    }
+  };
+  walk(root);
+  return out;
+}
+
 function countMd(dir) {
   try { return mdFiles(dir).length; } catch { return 0; }
 }