create-evda 0.1.4 → 0.1.5

package/README.md

@@ -14,7 +14,7 @@ npx create-evda my-evda
 
 ## 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.
+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 to organize it (a preset, or start plain), 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:
 
@@ -23,7 +23,7 @@ npx create-evda my-evda --yes --agent-name Iris --owner "Dana" --purpose "why wo
   --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`.
+`--platform` takes `claude`, `chatgpt` (ChatGPT and Codex), `gemini`, `cursor` or `other`. `--preset` takes a preset id or `none`; unattended, no flag means none. 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
 
@@ -44,6 +44,9 @@ Setup ends by asking whether to bring in what an AI you already talk to knows ab
     evda_search            plain text search inside the record, on this machine
     evda_circles           your circles and their policies
     evda_propose_circle    a proposal file under proposals/. Never a circle, never a grant
+    evda_presets           the preset library, or one preset's folders
+    evda_propose_structure what a preset would add to this record, in plain words. Writes nothing
+    evda_apply_preset      adds a preset's folders; refused unless confirmed: true, the owner's yes
     evda_doctor            evda doctor, as a report
 
 Every write appends, refuses anything shaped like a password, key or token, and says the path it wrote. `evda connect` prints the setup for your record, with its path filled in:
@@ -61,6 +64,19 @@ For the Claude desktop app, add the same command under `mcpServers` in `claude_d
 
 **Routines.** Setup offers a morning organize and a weekly look back, each optional, and schedules nothing without a yes. `evda routine morning` prints what to put in a local routine in the Claude desktop app (Code tab, then Routines, then New routine, then Local). `evda routine morning --install` writes and loads a launchd job instead, on a Mac. A cloud routine cannot read local files, so it cannot reach a record.
 
+## Presets
+
+How a record is organized comes from a library, so an agent proposes a folder that already exists in it instead of inventing one. Each preset is `presets/<id>/preset.json`: an `id`, a `title`, `for` (who it suits), `folders` (each a path, and for a typed folder its `type`, `connectors` and `views`, validated by the same code as `folder.evda.json`), optional `circles` (proposed as proposal files, never created) and optional `routines` (offered, never scheduled). Three ship: `projects-and-areas` (numbered top folders for inbox, projects, areas, resources, archive, captures, metadata and attachments), `journal`, and `student`. Setup offers them after purpose, with "none, start plain".
+
+    evda preset list
+    evda preset show <id>
+    evda preset apply <id> [--dry] [dir]
+    evda preset diff <id> [dir]      what the preset has that this record does not
+
+Applying only adds: missing directories are created and missing manifests written; a manifest that already says the same is skipped, one that says something else (or a file where a folder would go) is a `CONFLICT` that is left as it is, and nothing is moved, renamed or deleted. A second apply writes nothing. Exit 1 when there was a conflict. `test/presets.test.mjs` validates every shipped preset, so a malformed one fails a test rather than a person.
+
+`evda doctor` reads folder manifests across the whole record root, not only under the record roles, skipping dot-directories and `node_modules` and not following symlinks.
+
 ## 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.
@@ -134,6 +150,8 @@ The tree above is what the scaffolder creates and not a requirement. `evda.json`
     evda look-back [dir]           the week, read back by your own claude -p, appended to a report
     evda routine <morning|weekly> [dir] [--launchd] [--install]
                                    a Claude desktop routine, or a launchd job with --install
+    evda preset list | show <id> | apply <id> [--dry] [dir] | diff <id> [dir]
+                                   organize the record from the preset library; apply only adds
 
 The record is found through the locator: a directory argument, then `$EVDA_HOME`, then the nearest ancestor of the working directory holding `evda.json`, then `~/.evda/current`. Nothing assumes it was launched inside one.
 

package/bin/evda.mjs

@@ -61,11 +61,18 @@ const HELP = `evda: operate an EVDA. The files are the truth; this is optional.
   evda routine <morning|weekly> [dir] [--launchd] [--install]
                                  print a scheduled routine for Claude, or a launchd fallback; --install
                                  writes the launchd job, and nothing is scheduled without it
+  evda preset list               the organizations this package ships, and who each suits
+  evda preset show <id>          one preset's folders
+  evda preset apply <id> [--dry] [dir]
+                                 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 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> [--yes] [--agent-name N] [--owner O] [--purpose P] [--voice V]
                 [--platform claude|chatgpt|gemini|cursor|other] [--training-off] [--layers record,ledger]
+                [--preset <id>|none]
                                  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.
@@ -174,6 +181,46 @@ async function main(argv) {
       return routineMain(args, { pickDir, flagValue });
     }
 
+    case "preset": {
+      // evda preset list | show <id> | apply <id> [--dry] [dir] | diff <id> [dir]
+      const presets = await import("../lib/presets.mjs");
+      const [sub, ...rest] = args;
+      if (sub === "list") {
+        const all = presets.listPresets();
+        for (const p of all) console.log(`${p.id.padEnd(20)} ${p.title}: ${p.for}`);
+        console.log(`CHECKED ${all.length} presets`);
+        return all.length ? 0 : 1;
+      }
+      const id = rest.find((a) => !a.startsWith("--"));
+      if (!["show", "apply", "diff"].includes(sub) || !id) throw new EvdaError("usage: evda preset list | show <id> | apply <id> [--dry] [dir] | diff <id> [dir]", { exit: 2 });
+      if (sub === "show") {
+        const p = presets.loadPreset(id);
+        console.log(`${p.title} (${p.id}): ${p.for}`);
+        for (const f of p.folders) console.log(`  ${`${f.path}/`.padEnd(32)} ${(f.type ?? "untyped").padEnd(8)}${f.connectors?.length ? `  connectors ${f.connectors.join(", ")}` : ""}${f.note ? `  ${f.note}` : ""}`);
+        for (const c of p.circles ?? []) console.log(`  circle ${c.name} (${c.public ? "public" : "private"}, proposed only): ${c.description}`);
+        for (const r of p.routines ?? []) console.log(`  routine ${r} (offered, never scheduled without a yes)`);
+        return 0;
+      }
+      const { dir } = pickDir(rest.filter((a, i) => i !== rest.indexOf(id)));
+      if (sub === "diff") {
+        const plan = presets.diffPreset(dir, id);
+        console.log(`evda preset diff ${id}  ${plan.root}`);
+        for (const l of presets.planLines(plan, { diff: true })) console.log(l);
+        if (presets.planIsEmpty(plan)) console.log(`SKIPPED preset diff: this record already has everything ${id} makes`);
+        console.log(`CHECKED ${plan.folders} preset folders  ${plan.create.length} missing, ${plan.write.length} manifest(s) missing, ${plan.matched.length} matching, ${plan.conflicts.length} conflict(s)`);
+        return 0;
+      }
+      const dry = args.includes("--dry");
+      const plan = presets.applyPreset(dir, id, { dry });
+      console.log(`evda preset apply ${id}${dry ? " --dry" : ""}  ${plan.root}`);
+      for (const l of presets.planLines(plan)) console.log(l);
+      const wrote = plan.create.length + plan.write.length + plan.views.length + plan.proposed.length;
+      console.log(`CHECKED ${plan.folders} preset folders  ${plan.create.length} ${dry ? "to create" : "created"}, ${plan.write.length} manifest(s) ${dry ? "to write" : "written"}, ${plan.matched.length} skipped, ${plan.conflicts.length} conflict(s)`);
+      if (!dry && wrote === 0 && !plan.conflicts.length) console.log("Nothing was written: the record already has this preset.");
+      if (dry) console.log("Dry run: nothing was written.");
+      return plan.conflicts.length ? 1 : 0;
+    }
+
     case "where": {
       const found = locate({});
       console.log(`${found.dir}  (via ${found.via})`);

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]
-//                     [--name NAME] [--layers record,ledger[,circles]] [--force]
+//                     [--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
 // does not finish until the owner confirms model training is off for the AI they chose. With
@@ -30,6 +30,7 @@ import { FOLDER_MANIFEST } from "./lib/folders.mjs";
 import { EvdaError } from "./lib/errors.mjs";
 import { clients, installSkill } from "./lib/connect.mjs";
 import { desktopInstructions } from "./lib/routines.mjs";
+import { applyPreset, listPresets, planLines, presetIds, NONE } from "./lib/presets.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));
@@ -56,13 +57,13 @@ const FOLDER_TYPES = {
   "record/people": "person",
 };
 
-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] [--skill] [--routines morning,weekly] [--use] [--no-pointer]`;
+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] [--skill] [--routines morning,weekly] [--preset ${presetIds().join("|")}|none] [--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,
-    skill: null, routines: null,
+    skill: null, routines: null, preset: null,
   };
   const args = argv.flatMap((a) => {
     const eq = /^(--[a-z-]+)=([\s\S]*)$/.exec(a);
@@ -88,6 +89,10 @@ export function parseArgs(argv) {
       const bad = opts.routines.filter((r) => !["morning", "weekly"].includes(r));
       if (bad.length) throw new EvdaError(`--routines takes morning, weekly or both, got ${bad.join(", ")}`, { exit: 2 });
     }
+    else if (a === "--preset") {
+      opts.preset = value(++i, a).trim();
+      if (opts.preset !== NONE && !presetIds().includes(opts.preset)) throw new EvdaError(`--preset takes ${[...presetIds(), NONE].join(", ")}, got ${opts.preset}`, { exit: 2 });
+    }
     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);
@@ -234,7 +239,7 @@ export async function main(argv, io = null) {
     refuseNonEmpty(opts.dir, opts.force);
     const term = io ?? (await terminalIO());
     try {
-      opts = await interview(opts, term);
+      opts = await interview(opts, term, { presets: listPresets() });
     } finally {
       term.close?.();
     }
@@ -243,6 +248,13 @@ export async function main(argv, io = null) {
   const { dir, pointer } = scaffold(opts);
   log(`created an EVDA at ${dir}`);
   log(`locator ${pointer.path}: ${pointer.action}\n`);
+  // The chosen preset only adds folders to the fresh record, and doctor below reads what it wrote.
+  if (opts.preset && opts.preset !== NONE) {
+    const plan = applyPreset(dir, opts.preset);
+    log(`preset ${plan.id}: ${plan.title}`);
+    for (const l of planLines(plan)) log(l);
+    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.");

package/lib/doctor.mjs

@@ -318,12 +318,11 @@ export function doctor(dir, { out = console.log, via = "argument" } = {}) {
     else ok(grants.length, "grants", `across ${new Set(grants.map((g) => g.circle).filter(Boolean)).size} circle(s), ${grants.filter((g) => g.holder?.kind === "agent").length} to agents`);
   }
 
-  // 12. folder manifests (Spec 07, section 2): each record folder says what its entries are and
-  // which connectors feed its references. A manifest that is not JSON refuses the run.
+  // 12. folder manifests (Spec 07, section 2): each folder says what its entries are and which
+  // connectors feed its references. Read across the whole record root, not only the record roles
+  // (lib/folders.mjs folderManifests says why). A manifest that is not JSON refuses the run.
   let folders = [];
-  if (recordRoles.length === 0) {
-    skip("folder manifests", "no record role resolved to a directory");
-  } else {
+  {
     try {
       folders = folderManifests(evda);
     } catch (e) {
@@ -335,7 +334,7 @@ export function doctor(dir, { out = console.log, via = "argument" } = {}) {
       for (const p of f.problems) (p.level === "fail" ? fail : warn)(`folder ${relative(dir, f.dir) || "."}`, p.message);
       out(`        ${(relative(dir, f.dir) || ".").padEnd(24)} type ${f.type ?? "?"}  connectors [${f.connectors.join(", ")}]  views [${f.views.map((v) => v.view).join(", ")}]`);
     }
-    if (folders.length === 0) skip("folder manifests", `no record folder carries ${FOLDER_MANIFEST}`);
+    if (folders.length === 0) skip("folder manifests", `no folder in the record carries ${FOLDER_MANIFEST}`);
     else ok(folders.length, "folder manifests", `${folders.filter((f) => f.connectors.length).length} with connectors`);
 
     // 12b. views (Spec 07, section 5): a manifest's `views` declare the markdown files the renderer

package/lib/folders.mjs

@@ -112,24 +112,38 @@ export function validateFolderManifest(m, rel) {
   return out;
 }
 
-// Every folder manifest under the record's record roles, deepest last. Each item is
-// { rel, abs, dir, ...validateFolderManifest }. Throws only on a manifest that is not JSON.
+// Every folder manifest in the record. Each item is { rel, abs, dir, ...validateFolderManifest }.
+// Throws only on a manifest that is not JSON.
+//
+// The record roles are walked first, in role order and deepest last, then the rest of the record
+// root, because a folder a preset or the owner made outside every role still says what it holds and
+// is still read. Until HQ-1216 only the roles were walked, and a malformed manifest one level outside
+// them printed OK. The walk skips dot-directories and node_modules and does not follow a symlink
+// below a role or the root, so a link cannot pull another tree, or the same tree twice, into the count.
+//
+// FALSIFIED 2026-09-17: a fresh scaffold with Outside/folder.evda.json holding {"kind":"person"}
+// (no type). The roles-only walk (main at 2788455) printed "CHECKED 3 folder manifests" and
+// "OK  9 check(s), 0 warning(s)", exit 0. This walk prints "FAIL  folder Outside
+// Outside/folder.evda.json: has no "type". ..." and "CHECKED 4 folder manifests", exit 1.
 export function folderManifests(evda) {
   const out = [];
-  const roots = resolveAll(evda).filter((r) => r.known && r.mapped && r.layer === "record" && r.exists && r.isDir);
+  const seen = new Set();
   const walk = (dir) => {
+    if (seen.has(dir)) return;
+    seen.add(dir);
     const m = readFolderManifest(dir);
     if (m !== null) {
       const abs = join(dir, FOLDER_MANIFEST);
       out.push({ rel: relative(evda.dir, abs), abs, dir, ...validateFolderManifest(m, relative(evda.dir, abs)) });
     }
-    for (const name of readdirSync(dir).sort()) {
-      if (name.startsWith(".")) continue;
-      const p = join(dir, name);
-      if (statSync(p).isDirectory()) walk(p);
+    const entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    for (const e of entries) {
+      if (e.name.startsWith(".") || e.name === "node_modules") continue;
+      if (e.isDirectory()) walk(join(dir, e.name));
     }
   };
-  for (const r of roots) walk(r.abs);
+  for (const r of resolveAll(evda).filter((x) => x.known && x.mapped && x.layer === "record" && x.exists && x.isDir)) walk(r.abs);
+  walk(evda.dir);
   return out;
 }
 

package/lib/mcp.mjs

@@ -14,6 +14,7 @@ import { SCHEMA_VERSION } from "./manifest.mjs";
 import { openEvda } from "./manifest.mjs";
 import { EvdaError } from "./errors.mjs";
 import * as tools from "./tools.mjs";
+import * as presets from "./presets.mjs";
 
 // Newest first. The server answers with the client's version when it supports it, and with the
 // newest otherwise; the client decides whether to continue.
@@ -25,6 +26,7 @@ const INSTRUCTIONS = [
   "Call evda_operating_layer first and follow it for the whole session: it is who you are (Iris unless they renamed you) and how the record is kept.",
   "File the owner's words verbatim with evda_write in the same turn they say them, and report the path it returns in the past tense.",
   "Never quiz them. Never create a circle or grant; propose one with evda_propose_circle only when they ask to share, and wait for their yes.",
+  "Organization comes from the preset library (evda_presets): propose with evda_propose_structure, and apply with evda_apply_preset only after their yes.",
 ].join(" ");
 
 const str = (description) => ({ type: "string", description });
@@ -135,6 +137,47 @@ export const TOOLS = [
       return { text: `Wrote the proposal to ${r.path}. No circle was created and nobody was granted anything; that waits for the owner's yes.`, data: r };
     },
   },
+  {
+    name: "evda_presets",
+    title: "List presets",
+    description: "Lists the ways to organize a record that EVDA ships (the preset library), each with who it suits, or with an id shows one preset's folders. Read only. A new folder is proposed from a preset here, never invented.",
+    inputSchema: { type: "object", properties: { id: str("A preset id, to show that one. Omit to list them all.") }, additionalProperties: false },
+    annotations: { readOnlyHint: true, openWorldHint: false },
+    run: (evda, args) => {
+      const r = presets.presetsTool(evda, args);
+      if (r.presets) return { text: r.presets.map((p) => `${p.id}: ${p.title}. ${p.for} (${p.folders} folders)`).join("\n") };
+      const p = r.preset;
+      return { text: [`${p.id}: ${p.title}. ${p.for}`, ...p.folders.map((f) => `- ${f.path}/ ${f.type ?? "untyped"}${f.connectors?.length ? `, connectors ${f.connectors.join(", ")}` : ""}${f.note ? `: ${f.note}` : ""}`), ...(p.routines?.length ? [`routines it suits: ${p.routines.join(", ")}`] : [])].join("\n") };
+    },
+  },
+  {
+    name: "evda_propose_structure",
+    title: "Propose a preset's structure",
+    description: "Shows what applying a preset would add to this record, as a plan and a plain-language summary to show the owner. It never writes. Folders that already match are left alone, one that differs is reported and never changed, and nothing is ever moved, renamed or deleted.",
+    inputSchema: { type: "object", properties: { id: str("The preset id, from evda_presets.") }, required: ["id"], additionalProperties: false },
+    annotations: { readOnlyHint: true, openWorldHint: false },
+    run: (evda, args) => {
+      const r = presets.proposeStructureTool(evda, args);
+      return { text: `${r.summary}\n\nPlan:\n${presets.planLines(r.plan).join("\n") || "  nothing to add"}` };
+    },
+  },
+  {
+    name: "evda_apply_preset",
+    title: "Apply a preset",
+    description: "Adds a preset's folders and folder manifests to the record. Call it only after showing the owner evda_propose_structure and the owner said yes to this preset in this conversation; pass confirmed: true only then. It only adds: it never moves, renames, deletes or overwrites, and a circle in the preset becomes a proposal file, never a circle.",
+    inputSchema: {
+      type: "object",
+      properties: { id: str("The preset id the owner said yes to."), confirmed: { type: "boolean", description: "true only when the owner said yes to this preset in this conversation." } },
+      required: ["id", "confirmed"],
+      additionalProperties: false,
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    run: (evda, args) => {
+      const r = presets.applyPresetTool(evda, args);
+      const n = r.plan.create.length + r.plan.write.length;
+      return { text: `${n ? `Applied the ${r.plan.title} preset.` : `Nothing was written: the record already has the ${r.plan.title} preset.`}\n${r.lines.join("\n")}` };
+    },
+  },
   {
     name: "evda_doctor",
     title: "Check the record",

package/lib/presets.mjs

@@ -0,0 +1,328 @@
+// Presets: ways to organize a record, shipped as a library so an agent picks one instead of making
+// one up. Each is `presets/<id>/preset.json` in this package:
+//
+//   {
+//     "id": "journal",
+//     "title": "Journal",
+//     "for": "One sentence: who it suits.",
+//     "folders": [{ "path": "People", "type": "person", "connectors": ["contacts"], "note": "One file per person." }],
+//     "circles": [{ "name": "family", "public": false, "description": "...", "members": { "people": { "path": "People" } } }],
+//     "routines": ["weekly"]
+//   }
+//
+// `folders` are paths relative to the record root. A folder with a `type` gets folder.evda.json
+// (type, connectors, views), checked by the same validator doctor uses; a folder with no type is a
+// plain directory and nothing more. `circles` are starter circles, in the substrate's eco shape with
+// members by path, and they are only ever PROPOSED: a proposal file under proposals/, never a circle.
+// `routines` name routines lib/routines.mjs already knows, and are offered, never scheduled.
+//
+// Applying a preset only adds. It creates the directories that are missing, writes the manifests
+// that are missing, and reports the rest: a manifest that already says the same thing is skipped,
+// one that says something else is a conflict and is left exactly as it is, and a preset path that
+// already exists as a file is a conflict. Nothing is moved, renamed or deleted, so applying twice
+// writes nothing the second time. A shipped preset that does not validate fails
+// test/presets.test.mjs, so the person running it never meets one.
+
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { openEvda } from "./manifest.mjs";
+import { resolveRole } from "./roles.mjs";
+import { validateFolderManifest, FOLDER_MANIFEST, FOLDER_TYPES } from "./folders.mjs";
+import { ROUTINE_KEYS } from "./routines.mjs";
+import { onlyKeys, proposeCircle, refuse, PROPOSALS } from "./tools.mjs";
+import { EvdaError } from "./errors.mjs";
+
+export const PRESETS_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..", "presets");
+export const PRESET_FILE = "preset.json";
+export const PRESET_KEYS = ["id", "title", "for", "folders", "circles", "routines"];
+export const PRESET_FOLDER_KEYS = ["path", "type", "connectors", "views", "note"];
+export const PRESET_CIRCLE_KEYS = ["name", "public", "description", "members"];
+export const NONE = "none";
+
+const isObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+const nonEmpty = (v) => typeof v === "string" && v.trim() !== "";
+const ID = /^[a-z0-9][a-z0-9-]*$/;
+const CIRCLE_NAME = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+
+// A preset path: relative, forward slashes, no empty, dot or dot-dot segment, and no segment doctor's
+// walk would skip (a dot-directory or node_modules), because a folder doctor cannot see is a promise
+// nothing checks.
+function pathProblem(p) {
+  if (!nonEmpty(p)) return "must be a non-empty path";
+  if (p.includes("\\")) return "uses a backslash; paths use /";
+  if (p.startsWith("/")) return "is absolute; paths are relative to the record root";
+  for (const seg of p.split("/")) {
+    if (seg === "" || seg === "." || seg === "..") return `has an empty, . or .. segment`;
+    if (seg.startsWith(".") || seg === "node_modules") return `has the segment "${seg}", which doctor does not read`;
+  }
+  return null;
+}
+
+// Validate one preset. Returns a list of problem strings; empty is valid. Stricter than a folder
+// manifest on disk: an unknown key or type in something this package ships is a mistake, not a
+// newer tool's key to preserve.
+export function validatePreset(p, dirName = null) {
+  const problems = [];
+  const fail = (m) => problems.push(`${dirName ?? p?.id ?? "preset"}: ${m}`);
+  if (!isObject(p)) { fail("must hold a JSON object."); return problems; }
+  const unknown = Object.keys(p).filter((k) => !PRESET_KEYS.includes(k));
+  if (unknown.length) fail(`unknown key(s): ${unknown.join(", ")}.`);
+  if (!nonEmpty(p.id) || !ID.test(p.id)) fail(`"id" must be lowercase letters, digits and -, got ${JSON.stringify(p.id)}.`);
+  else if (dirName !== null && p.id !== dirName) fail(`"id" is ${JSON.stringify(p.id)} but the preset lives in ${dirName}/; the directory names it.`);
+  if (!nonEmpty(p.title)) fail(`"title" is missing.`);
+  if (!nonEmpty(p.for)) fail(`"for" is missing: one sentence saying who it suits.`);
+  else if (/\n/.test(p.for)) fail(`"for" is one sentence on one line.`);
+  const paths = new Set();
+  if (!Array.isArray(p.folders) || p.folders.length === 0) fail(`"folders" must be a non-empty list.`);
+  else {
+    p.folders.forEach((f, i) => {
+      const at = `folders[${i}]`;
+      if (!isObject(f)) { fail(`${at} must be { path, type?, connectors?, views?, note? }.`); return; }
+      const extra = Object.keys(f).filter((k) => !PRESET_FOLDER_KEYS.includes(k));
+      if (extra.length) fail(`${at} unknown key(s): ${extra.join(", ")}.`);
+      const bad = pathProblem(f.path);
+      if (bad) { fail(`${at} path ${bad}.`); return; }
+      if (paths.has(f.path)) fail(`${at} path ${f.path} is listed twice.`);
+      paths.add(f.path);
+      if (f.note !== undefined && !nonEmpty(f.note)) fail(`${at} "note" must be a sentence.`);
+      if (f.type === undefined) {
+        if (f.connectors !== undefined || f.views !== undefined) fail(`${at} (${f.path}) has connectors or views and no type. An untyped folder is a plain directory with no manifest to hold them.`);
+        return;
+      }
+      if (!FOLDER_TYPES.includes(f.type)) fail(`${at} (${f.path}) type ${JSON.stringify(f.type)} is not one of ${FOLDER_TYPES.join(", ")}.`);
+      const v = validateFolderManifest(manifestFor(f), `${f.path}/${FOLDER_MANIFEST}`);
+      for (const pr of v.problems) fail(pr.message);
+      for (const view of f.views ?? []) {
+        if (isObject(view) && nonEmpty(view.path) && pathProblem(view.path)) fail(`${at} view "${view.view}" path ${pathProblem(view.path)}.`);
+      }
+    });
+  }
+  if (p.circles !== undefined) {
+    if (!Array.isArray(p.circles)) fail(`"circles" must be a list.`);
+    else {
+      const names = new Set();
+      p.circles.forEach((c, i) => {
+        const at = `circles[${i}]`;
+        if (!isObject(c)) { fail(`${at} must be { name, public, description, members }.`); return; }
+        const extra = Object.keys(c).filter((k) => !PRESET_CIRCLE_KEYS.includes(k));
+        if (extra.length) fail(`${at} unknown key(s): ${extra.join(", ")}.`);
+        if (!nonEmpty(c.name) || !CIRCLE_NAME.test(c.name)) fail(`${at} "name" must be letters, digits, - and _.`);
+        else if (names.has(c.name)) fail(`${at} circle ${c.name} is listed twice.`);
+        else names.add(c.name);
+        if (typeof c.public !== "boolean") fail(`${at} "public" must be true or false.`);
+        if (!nonEmpty(c.description)) fail(`${at} "description" says in plain words who may read it and why.`);
+        if (!isObject(c.members) || Object.keys(c.members).length === 0) { fail(`${at} "members" must name at least one path.`); return; }
+        for (const [name, m] of Object.entries(c.members)) {
+          if (!isObject(m) || Object.keys(m).length !== 1 || !nonEmpty(m.path)) { fail(`${at} member "${name}" must be { path }; a preset circle holds folders this preset makes.`); continue; }
+          if (![...paths].some((fp) => m.path === fp || m.path.startsWith(`${fp}/`))) fail(`${at} member "${name}" path ${m.path} is not a folder this preset makes.`);
+        }
+      });
+    }
+  }
+  if (p.routines !== undefined) {
+    if (!Array.isArray(p.routines)) fail(`"routines" must be a list.`);
+    else {
+      for (const r of p.routines) if (!ROUTINE_KEYS.includes(r)) fail(`routine ${JSON.stringify(r)} is not one this package has (${ROUTINE_KEYS.join(", ")}).`);
+      if (new Set(p.routines).size !== p.routines.length) fail(`"routines" lists one twice.`);
+    }
+  }
+  return problems;
+}
+
+// The folder.evda.json a typed preset folder writes. The same three keys the scaffold writes.
+export function manifestFor(folder) {
+  return { type: folder.type, connectors: folder.connectors ?? [], views: folder.views ?? [] };
+}
+
+// Read one preset from `dir` (the presets directory). Throws when it is missing or does not validate.
+export function loadPreset(id, { dir = PRESETS_DIR } = {}) {
+  if (!nonEmpty(id) || !ID.test(id)) throw new EvdaError(`REFUSED: ${JSON.stringify(id)} is not a preset id. Presets: ${presetIds({ dir }).join(", ")}.`, { code: "NO_PRESET", exit: 2 });
+  const p = join(dir, id, PRESET_FILE);
+  if (!existsSync(p)) throw new EvdaError(`REFUSED: no preset named "${id}". Presets: ${presetIds({ dir }).join(", ")}.`, { code: "NO_PRESET", exit: 2 });
+  let preset;
+  try {
+    preset = JSON.parse(readFileSync(p, "utf8"));
+  } catch (e) {
+    throw new EvdaError(`REFUSED: preset ${id} is not valid JSON (${e.message}).`, { code: "BAD_PRESET", exit: 2 });
+  }
+  const problems = validatePreset(preset, id);
+  if (problems.length) throw new EvdaError(`REFUSED: preset ${id} is malformed: ${problems[0]}`, { code: "BAD_PRESET", exit: 2 });
+  return preset;
+}
+
+export function presetIds({ dir = PRESETS_DIR } = {}) {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir).filter((n) => !n.startsWith(".") && existsSync(join(dir, n, PRESET_FILE))).sort();
+}
+
+// Every shipped preset, loaded and validated.
+export function listPresets(opts = {}) {
+  return presetIds(opts).map((id) => loadPreset(id, opts));
+}
+
+// What `folder`'s existing manifest lacks against the preset's: a different type, a connector or a
+// view the preset declares and it does not. [] means it already says what the preset says; a
+// connector or view the owner added beyond the preset is theirs and is not a difference.
+function differences(existing, want) {
+  const out = [];
+  if (!isObject(existing)) return ["it does not hold a JSON object"];
+  if (existing.type !== want.type) out.push(`its type is ${JSON.stringify(existing.type)}, the preset's is "${want.type}"`);
+  const has = Array.isArray(existing.connectors) ? existing.connectors : [];
+  const missing = want.connectors.filter((c) => !has.includes(c));
+  if (missing.length) out.push(`it does not declare connector(s) ${missing.join(", ")}`);
+  const views = Array.isArray(existing.views) ? existing.views.map((v) => v?.view) : [];
+  const noView = want.views.filter((v) => !views.includes(v.view)).map((v) => v.view);
+  if (noView.length) out.push(`it does not declare view(s) ${noView.join(", ")}`);
+  return out;
+}
+
+// The first segment of `rel` that exists and is not a directory, or null.
+function blockedBy(root, rel) {
+  const segs = rel.split("/");
+  for (let i = 1; i <= segs.length; i++) {
+    const sub = segs.slice(0, i).join("/");
+    const abs = join(root, sub);
+    let st;
+    try { st = lstatSync(abs); } catch { return null; }
+    if (st.isSymbolicLink()) { try { st = statSync(abs); } catch { return sub; } }
+    if (!st.isDirectory()) return sub;
+  }
+  return null;
+}
+
+const viewHeader = (v) => ["---", `view: ${v.view}`, `of: ${v.of}`, `in: ${v.in}`, "---", ""].join("\n");
+
+// The plan for applying preset `id` to the record at `root`, and with `dry: false` the writes.
+//   create     directories that do not exist yet
+//   write      manifests that do not exist yet ({ path, folder, manifest })
+//   views      view files a manifest declares that do not exist yet
+//   matched    manifests that exist and already say what the preset says (skipped)
+//   conflicts  manifests that exist and say something else, and preset paths that are files
+//              ({ path, why }); reported, never overwritten
+//   circles    preset circles with no circle and no proposal yet, proposed on apply
+//   routines   routines the preset suggests, offered and never scheduled
+export function applyPreset(root, id, { dry = false, now = new Date(), dir = PRESETS_DIR } = {}) {
+  const evda = openEvda(resolve(root));
+  const preset = loadPreset(id, { dir });
+  const plan = { id: preset.id, title: preset.title, root: evda.dir, dry, create: [], write: [], views: [], matched: [], conflicts: [], circles: [], proposed: [], routines: preset.routines ?? [], folders: preset.folders.length };
+  const blocked = new Set();
+  for (const f of preset.folders) {
+    const abs = resolve(evda.dir, f.path);
+    if (!abs.startsWith(evda.dir + sep)) { plan.conflicts.push({ path: f.path, why: "resolves outside the record" }); continue; }
+    const file = blockedBy(evda.dir, f.path);
+    if (file) {
+      if (!blocked.has(file)) plan.conflicts.push({ path: file, why: `exists as a file, so the folder ${f.path} cannot be made there` });
+      blocked.add(file);
+      continue;
+    }
+    if (!existsSync(abs) && !plan.create.includes(f.path)) plan.create.push(f.path);
+    if (f.type === undefined) continue;
+    const want = manifestFor(f);
+    const mpath = `${f.path}/${FOLDER_MANIFEST}`;
+    const mabs = join(abs, FOLDER_MANIFEST);
+    if (!existsSync(mabs)) plan.write.push({ path: mpath, folder: f, manifest: want });
+    else if (!lstatSync(mabs).isFile()) plan.conflicts.push({ path: mpath, why: "exists and is not a file" });
+    else {
+      let existing;
+      try { existing = JSON.parse(readFileSync(mabs, "utf8")); } catch { plan.conflicts.push({ path: mpath, why: "exists and is not valid JSON" }); continue; }
+      const diff = differences(existing, want);
+      if (diff.length) plan.conflicts.push({ path: mpath, why: `exists and differs: ${diff.join("; ")}` });
+      else plan.matched.push({ path: mpath });
+    }
+    for (const v of want.views) {
+      if (!existsSync(resolve(evda.dir, v.path))) plan.views.push({ path: v.path, view: v });
+    }
+  }
+  const circlesRole = resolveRole(evda, "circles");
+  const proposals = join(evda.dir, PROPOSALS);
+  const proposalNames = existsSync(proposals) ? readdirSync(proposals) : [];
+  for (const c of preset.circles ?? []) {
+    const exists = circlesRole.mapped && existsSync(join(circlesRole.abs, c.name));
+    const proposed = proposalNames.some((n) => new RegExp(`^\\d{4}-\\d{2}-\\d{2}-circle-${c.name}(-\\d+)?\\.md$`).test(n));
+    if (!exists && !proposed) plan.circles.push(c);
+  }
+  if (dry) return plan;
+
+  for (const rel of plan.create) mkdirSync(join(evda.dir, rel), { recursive: true });
+  for (const w of plan.write) writeFileSync(join(evda.dir, w.path), JSON.stringify(w.manifest, null, 2) + "\n", { flag: "wx" });
+  for (const v of plan.views) {
+    mkdirSync(dirname(resolve(evda.dir, v.path)), { recursive: true });
+    writeFileSync(resolve(evda.dir, v.path), viewHeader(v.view), { flag: "wx" });
+  }
+  for (const c of plan.circles) {
+    const r = proposeCircle(evda, {
+      name: c.name,
+      who: c.public ? "Anyone." : "Only the people the owner grants it to, by name.",
+      what: Object.values(c.members).map((m) => m.path).join(", "),
+      why: `${c.description} Suggested by the ${preset.title} preset.`,
+    }, { now });
+    plan.proposed.push(r.path);
+  }
+  return plan;
+}
+
+// What preset `id` has that the record at `root` does not: the dry-run plan, which by construction
+// holds only additions and conflicts. This is how an agent proposes one folder from the library later.
+export function diffPreset(root, id, opts = {}) {
+  return applyPreset(root, id, { ...opts, dry: true });
+}
+
+export const planIsEmpty = (plan) => !plan.create.length && !plan.write.length && !plan.views.length && !plan.circles.length && !plan.conflicts.length;
+
+// The plan in plain words, for the owner to say yes or no to. Names each folder by its note.
+export function summary(plan, preset = loadPreset(plan.id)) {
+  const lines = [];
+  const adds = preset.folders.filter((f) => plan.create.includes(f.path) || plan.write.some((w) => w.folder.path === f.path));
+  if (!adds.length && !plan.circles.length && !plan.conflicts.length) {
+    lines.push(`This record already has everything the ${plan.title} preset makes. Nothing would be written.`);
+  } else {
+    lines.push(`The ${plan.title} preset would add ${adds.length} folder(s) to this record:`);
+    for (const f of adds) lines.push(`- ${f.path}/${f.type ? ` (${f.type})` : ""}${f.note ? `: ${f.note}` : ""}`);
+    if (plan.circles.length) lines.push(`It would propose ${plan.circles.length} circle(s), as proposal files only: ${plan.circles.map((c) => c.name).join(", ")}.`);
+    if (plan.matched.length) lines.push(`${plan.matched.length} folder(s) are already set up the same way and would be left alone.`);
+    for (const c of plan.conflicts) lines.push(`Left as it is: ${c.path} ${c.why}.`);
+    lines.push("Nothing is moved, renamed or deleted. It is applied only when the owner says yes.");
+  }
+  if (plan.routines.length) lines.push(`It suits the ${plan.routines.join(" and ")} routine(s), offered separately and never scheduled without a yes.`);
+  return lines.join("\n");
+}
+
+// Plan lines for the CLI, in the package's CHECKED / SKIPPED convention.
+export function planLines(plan, { diff = false } = {}) {
+  const out = [];
+  const verb = plan.dry || diff ? "would" : "did";
+  for (const p of plan.create) out.push(`  ${verb === "did" ? "created " : "create  "} ${p}/`);
+  for (const w of plan.write) out.push(`  ${verb === "did" ? "wrote   " : "write   "} ${w.path}  type ${w.manifest.type}${w.manifest.connectors.length ? `, connectors ${w.manifest.connectors.join(", ")}` : ""}`);
+  for (const v of plan.views) out.push(`  ${verb === "did" ? "wrote   " : "write   "} ${v.path}  view ${v.view.view} (header only)`);
+  if (!diff) for (const m of plan.matched) out.push(`  skipped  ${m.path}  already says the same`);
+  for (const c of plan.conflicts) out.push(`  CONFLICT ${c.path}  ${c.why}. Left as it is.`);
+  if (plan.proposed.length) for (const p of plan.proposed) out.push(`  proposed ${p}  (a proposal file; no circle was created)`);
+  else for (const c of plan.circles) out.push(`  propose  circle ${c.name}  (a proposal file only)`);
+  for (const r of plan.routines) out.push(`  offer    routine ${r}: evda routine ${r}  (nothing is scheduled without a yes)`);
+  return out;
+}
+
+// The MCP tools. Each takes the open record and its arguments, and refuses an argument it does not take.
+
+export function presetsTool(evda, args = {}) {
+  onlyKeys("evda_presets", args, ["id"]);
+  if (args.id === undefined) return { presets: listPresets().map((p) => ({ id: p.id, title: p.title, for: p.for, folders: p.folders.length })) };
+  return { preset: loadPreset(args.id) };
+}
+
+export function proposeStructureTool(evda, args = {}) {
+  onlyKeys("evda_propose_structure", args, ["id"], "It only proposes. Applying a preset is evda_apply_preset, after the owner says yes.");
+  if (!nonEmpty(args.id)) throw refuse(`evda_propose_structure needs "id", a preset from evda_presets.`, "NO_PRESET");
+  const plan = applyPreset(evda.dir, args.id, { dry: true });
+  return { plan, summary: summary(plan) };
+}
+
+export function applyPresetTool(evda, args = {}, { now = new Date() } = {}) {
+  onlyKeys("evda_apply_preset", args, ["id", "confirmed"], "It adds the preset's folders and manifests and nothing else; it never moves, renames or deletes.");
+  if (!nonEmpty(args.id)) throw refuse(`evda_apply_preset needs "id", a preset from evda_presets.`, "NO_PRESET");
+  if (args.confirmed !== true) throw refuse(`evda_apply_preset needs "confirmed": true, and that is true only when the owner said yes to this preset in this conversation. Show them evda_propose_structure first and wait.`, "NOT_CONFIRMED");
+  loadPreset(args.id);
+  const plan = applyPreset(evda.dir, args.id, { now });
+  return { plan, lines: planLines(plan) };
+}

package/lib/setup.mjs

@@ -174,6 +174,7 @@ export function questions(agent = DEFAULT_AGENT_NAME) {
     { key: "agentName", text: `What would you like to call your agent? (${DEFAULT_AGENT_NAME})` },
     { key: "owner", text: "What is your name?" },
     { key: "purpose", text: `What do you want ${agent} for? Say it however it comes out.` },
+    { key: "preset", text: "How should your EVÐA be organized? Pick a starting set of folders, or start plain. Nothing you already have is moved." },
     { key: "voice", text: `How do you want ${agent} to talk to you?` },
     { key: "platform", text: "Which AI will you use it with?" },
     { key: "trainingOff", text: "Before anything personal goes in, turn model training off:" },
@@ -192,10 +193,27 @@ export function importLines(agent = DEFAULT_AGENT_NAME) {
   };
 }
 
+// The preset choice: a number from the menu (the last number is "none"), a preset id, a word from
+// its title, or none. `presets` is [{ id, title, for }], passed in rather than read here, because
+// this file is also bundled into the EVÐA app and reads no files. null when the answer names nothing.
+export const START_PLAIN = "None, start plain";
+export function presetKey(answer, presets) {
+  const a = String(answer ?? "").trim().toLowerCase();
+  if (!a || a === "none" || a === "plain" || a === START_PLAIN.toLowerCase()) return "none";
+  if (/^\d+$/.test(a)) {
+    const n = Number(a);
+    if (n === presets.length + 1) return "none";
+    return presets[n - 1]?.id ?? null;
+  }
+  const hit = presets.find((p) => p.id === a || p.title.toLowerCase() === a);
+  return hit ? hit.id : null;
+}
+
 // Ask the setup questions one at a time. `io.ask(prompt)` returns the answer (a promise or a
 // string); `io.out(line)` prints. Only questions whose flag is missing are asked. Returns the
-// answers, including `trainingOff` which is true only after the owner typed yes.
-export async function interview(opts, io) {
+// answers, including `trainingOff` which is true only after the owner typed yes. `presets` is the
+// preset library to offer; with none, the preset question is not asked.
+export async function interview(opts, io, { presets = [] } = {}) {
   const out = io.out;
   const ask = async (q) => oneLine(await io.ask(q));
   out(WELCOME);
@@ -206,6 +224,14 @@ export async function interview(opts, io) {
   const agent = a.agentName || DEFAULT_AGENT_NAME;
   if (!a.owner) a.owner = await ask(`${q("owner", agent)} `);
   if (!a.purpose) a.purpose = await ask(`${q("purpose", agent)} `);
+  if (a.preset == null && presets.length) {
+    out(q("preset", agent));
+    presets.forEach((p, i) => out(`  ${i + 1}. ${p.title}: ${p.for}`));
+    out(`  ${presets.length + 1}. ${START_PLAIN}`);
+    let key = null;
+    while (!key) key = presetKey(await ask("Number or name: "), presets);
+    a.preset = key;
+  }
   if (!a.voice) a.voice = await ask(`${q("voice", agent)} `);
   if (!a.platform) {
     out(q("platform", agent));

package/lib/tools.mjs

@@ -32,13 +32,13 @@ const DATE = /^\d{4}-\d{2}-\d{2}$/;
 const MAX_WORDS = 200_000;
 const MAX_READ = 256_000;
 
-function refuse(message, code = "REFUSED") {
+export function refuse(message, code = "REFUSED") {
   return new EvdaError(`REFUSED: ${message} Nothing was written.`, { code, exit: 2 });
 }
 
 // Arguments a tool does not take are refused by name, so an agent that tries to pass a path or a
 // replacement learns the tool cannot do that, instead of the key being silently ignored.
-function onlyKeys(tool, args, allowed, hint = "") {
+export function onlyKeys(tool, args, allowed, hint = "") {
   const extra = Object.keys(args ?? {}).filter((k) => !allowed.includes(k));
   if (extra.length) throw refuse(`${tool} does not take ${extra.map((k) => JSON.stringify(k)).join(", ")}.${hint ? ` ${hint}` : ""}`, "UNKNOWN_ARGUMENT");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-evda",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Make your own EVÐA: a running journal of your life with Iris, as plain files on your machine, for any AI. Connect Claude Code, Codex or the Claude app over MCP. No runtime dependencies.",
   "type": "module",
   "bin": {
@@ -16,6 +16,7 @@
     "templates",
     "skills",
     "migrations",
+    "presets",
     "create-evda.mjs",
     "README.md",
     "LICENSE"

package/presets/journal/preset.json

@@ -0,0 +1,11 @@
+{
+  "id": "journal",
+  "title": "Journal",
+  "for": "Someone who mostly wants to write about their days and the people in them, with little structure.",
+  "folders": [
+    { "path": "Journal", "type": "record", "note": "One file per day, named YYYY-MM-DD.md." },
+    { "path": "Captures", "type": "capture", "note": "A thought as it arrived." },
+    { "path": "People", "type": "person", "connectors": ["contacts"], "note": "One file per person." },
+    { "path": "Notes", "type": "concept", "note": "Ideas worth keeping past the day." }
+  ]
+}

package/presets/projects-and-areas/preset.json

@@ -0,0 +1,27 @@
+{
+  "id": "projects-and-areas",
+  "title": "Projects and areas",
+  "for": "Someone running several projects and parts of life at once, who captures fast, sorts later, and looks back each week.",
+  "folders": [
+    { "path": "00_Inbox", "note": "Anything not sorted yet." },
+    { "path": "01_Projects", "type": "project", "note": "Work with an end: one folder per project." },
+    { "path": "02_Areas", "note": "Parts of life with no end date: one folder per area." },
+    { "path": "02_Areas/Academics", "note": "One folder per course below this one, typed course." },
+    { "path": "02_Areas/Relationships/People", "type": "person", "connectors": ["contacts"], "note": "One file per person." },
+    { "path": "03_Resources", "note": "Reference material kept for later." },
+    { "path": "03_Resources/Raw", "type": "source", "connectors": ["url"], "note": "Sources as they arrived, unedited." },
+    { "path": "03_Resources/Wiki/Concepts", "type": "concept", "note": "One page per recurring idea, named." },
+    { "path": "03_Resources/Wiki/Syntheses", "type": "concept", "note": "Connections worked out across ideas." },
+    { "path": "03_Resources/Wiki/Sources", "type": "source", "connectors": ["url"], "note": "A summary per source cited often." },
+    { "path": "04_Archive", "note": "Finished or dropped, kept as it was." },
+    { "path": "05_Process", "type": "capture", "note": "Captures waiting to be filed." },
+    { "path": "05_Process/Processed", "type": "capture", "note": "Captures already filed, kept." },
+    { "path": "05_Process/_media", "type": "blob", "note": "Photos and audio a capture carried." },
+    { "path": "06_Metadata", "note": "The record about the record." },
+    { "path": "06_Metadata/Daily Journal", "type": "record", "note": "One file per day, named YYYY-MM-DD.md." },
+    { "path": "06_Metadata/Weekly Reviews", "type": "concept", "note": "One look back per week." },
+    { "path": "06_Metadata/Templates", "note": "Note templates." },
+    { "path": "07_Attachments", "note": "Files notes link to." }
+  ],
+  "routines": ["morning", "weekly"]
+}

package/presets/student/preset.json

@@ -0,0 +1,13 @@
+{
+  "id": "student",
+  "title": "Student",
+  "for": "Someone in school who keeps courses, readings and projects alongside their own days.",
+  "folders": [
+    { "path": "Journal", "type": "record", "note": "One file per day, named YYYY-MM-DD.md." },
+    { "path": "Courses", "note": "One folder per course below this one, typed course." },
+    { "path": "People", "type": "person", "connectors": ["contacts"], "note": "One file per person." },
+    { "path": "Projects", "type": "project", "note": "Work with an end: one folder per project." },
+    { "path": "Readings", "type": "source", "connectors": ["url"], "note": "What was assigned or read, with a link." },
+    { "path": "Captures", "type": "capture", "note": "A thought as it arrived." }
+  ]
+}

package/skills/evda/SKILL.md

@@ -46,6 +46,24 @@ setup for each client. Do not keep the record some other way.
 - **Never create a circle, grant anyone access, or move an entry into one.** That is their explicit
   yes, done by them (`evda grant`), never by you.
 
+## How the record is organized
+
+Organization comes from the preset library, never from you making one up.
+
+- **During setup**, or when they ask how to organize their EVÐA: list the presets with
+  `evda_presets`, say in one line which fits what they told you and why, show the plan with
+  `evda_propose_structure`, and wait for their yes. Only then call `evda_apply_preset` with
+  `confirmed: true`. A yes to something else is not a yes to this.
+- **Later, only when a new kind of thing keeps appearing** (courses, readings, the same kind of
+  note again and again) and a folder in a preset already covers it: name that folder from the
+  library, show it with `evda_propose_structure`, and wait. Never invent a folder the library does
+  not have.
+- **Applying only adds.** It never moves, renames or deletes, and a folder that is already set up
+  differently is reported and left alone. Tell them what it reported.
+- **Where something shared goes:** a plain folder when it is theirs and private; a circle when it
+  is theirs and shared with specific people; its own EVÐA when someone else holds it or it will
+  outlive their involvement (a company, a team's project).
+
 ## Organizing (scheduled or asked)
 
 `evda organize` does the mechanical part itself: it copies each capture, verbatim, into the daily

package/templates/AGENTS.md

@@ -205,12 +205,14 @@ help with that too. There is almost always a way to live well in the situation t
 1. Read this file to the end, including "What I have been taught".
 2. **If any field in "What this EVÐA is" is empty, set it up first,** conversationally. **One question
    per message**, in this order, each its own turn: what to call you (Iris if they have no preference),
-   who they are, what they want this for, how they want you to talk, which AI they use with you, and
+   who they are, what they want this for, how to organize it, how they want you to talk, which AI they use with you, and
    then whether model training is off for it. Write each answer into that section **in their exact
    words**, hedges intact. **Before anything personal is written, training must be confirmed off.**
    Give the steps only from the "Turning training off" section of `README.md`; **never give a setting
    name or a provider's data policy from memory**, because those change and a wrong one is a privacy
-   failure. Once it is confirmed, file anything personal they already said during setup.
+   failure. Once it is confirmed, file anything personal they already said during setup. For how to
+   organize it, offer the presets by name and who each suits, or none, and apply the one they pick
+   only after their yes (see "Where things go").
 3. Read the last few days of `record/` and anything they point you at.
 4. Say in one line what you read, then answer them.
 
@@ -255,6 +257,14 @@ belongs and follow that type's shape. Point at what lives elsewhere (a contact,
 another person's EVÐA) with a reference, never a copy. Never write a password, key or token into the
 record. Run `evda doctor` after structural changes when the platform allows it.
 
+- **Organization comes from the preset library.** `evda preset list` shows each preset and who it
+  suits. Propose one, show what it would add with `evda preset apply <id> --dry`, and apply it only
+  after their yes. Applying only adds; nothing is moved, renamed or deleted.
+- **A new folder is proposed from a preset, never invented.** When a new kind of thing keeps
+  appearing and a preset already has a folder for it, name that folder (`evda preset diff <id>`
+  lists what the record lacks) and wait for their yes.
+- **A plain folder when it is theirs and private; a circle when it is theirs and shared with specific people; its own EVÐA when someone else holds it or it will outlive their involvement (a company, a team's project).**
+
 ## Reads held loosely
 
 - **Parked is the default.** A read about them goes in `ledger/` only when they have agreed it

package/templates/evda-digest.md

@@ -58,6 +58,9 @@ Instruction-only digest of the generated block of AGENTS.md. Read AGENTS.md in f
 - Nothing is scored
 - Never set a rule about their life with a threshold, count, streak or quota
 ## Where things go
+- Organization comes from the preset library
+- A new folder is proposed from a preset, never invented
+- A plain folder when it is theirs and private; a circle when it is theirs and shared with specific people; its own EVÐA when someone else holds it or it will outlive their involvement (a company, a team's project)
 ## Reads held loosely
 - Parked is the default
 - Never quiz them about it and never list what is open