create-evda 0.1.2 → 0.1.4

package/lib/organize.mjs

@@ -0,0 +1,224 @@
+// `evda organize`: go through what the owner left inward and say where it belongs. Moves nothing.
+//
+// The mechanical part is deterministic and done here:
+//   - each dated capture is copied, verbatim, into the daily file of its date, once. A marker comment
+//     in the daily file records the copy, so a second run files nothing twice and a rebuilt .evda/
+//     cannot make it forget.
+//   - the report lists what needs a person's judgment: people a recent note mentions whose file has
+//     nothing from that note, imports to check, undated notes, and notes that sit under no role.
+// The report is appended to reports/organize/<date>.md. Nothing is moved, renamed or deleted, and
+// nothing is written into circles/ or grants/.
+//
+// The judgment part runs through the owner's own AI (`--with-ai`): `claude -p` with the evda skill
+// and read-only EVDA tools, given the report. Its answer is appended to the same report. EVDA holds
+// no key and calls no model; `claude` is the owner's install, signed in as the owner.
+
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative } from "node:path";
+import { spawnSync } from "node:child_process";
+import { resolveRole, resolveAll } from "./roles.mjs";
+import { mdFiles, fileDate } from "./record.mjs";
+import { secretShape } from "./references.mjs";
+import { importsDir, localDate, localTime } from "./tools.mjs";
+import { serverCommand, SKILL_SOURCE } from "./connect.mjs";
+import { SERVER_NAME } from "./clients.mjs";
+import { EvdaError } from "./errors.mjs";
+
+export const REPORTS = "reports";
+const marker = (rel) => `<!-- evda:capture ${rel} -->`;
+const posix = (p) => p.split("\\").join("/");
+
+function stripFrontmatter(text) {
+  if (!text.startsWith("---\n")) return text;
+  const end = text.indexOf("\n---", 3);
+  if (end === -1) return text;
+  return text.slice(text.indexOf("\n", end + 1) + 1);
+}
+
+function secretLine(text) {
+  for (const line of text.split("\n")) {
+    const s = secretShape(line);
+    if (s) return s;
+  }
+  return null;
+}
+
+// A person's names: the first `# ` heading and the file's stem with - and _ as spaces.
+function personNames(abs, text) {
+  const names = new Set();
+  const h = /^# (.+)$/m.exec(text);
+  if (h) names.add(h[1].trim());
+  names.add(basename(abs, ".md").replace(/[-_]+/g, " ").trim());
+  return [...names].filter((n) => n.length >= 2);
+}
+
+const mentions = (text, name) => new RegExp(`(^|[^\\p{L}\\p{N}])${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}($|[^\\p{L}\\p{N}])`, "iu").test(text);
+
+// What organize would do and has to say, without writing. `window` is how many days back a note
+// counts as recent for the people check.
+export function plan(evda, { now = new Date(), window = 7 } = {}) {
+  const rel = (abs) => posix(relative(evda.dir, abs));
+  const daily = resolveRole(evda, "record/daily");
+  const captures = resolveRole(evda, "record/captures");
+  const people = resolveRole(evda, "record/people");
+  if (!daily.mapped || !daily.exists) throw new EvdaError('organize needs a "record/daily" role that exists; it files captures into their day.', { code: "NO_ROLE", exit: 2 });
+  const start = new Date(now);
+  start.setDate(start.getDate() - (window - 1));
+  const from = localDate(start);
+  const out = { filings: [], people: [], imports: [], undated: [], unplaced: [], refused: [], examined: 0 };
+
+  // Captures into their day.
+  if (captures.mapped && captures.exists) {
+    for (const abs of mdFiles(captures.abs)) {
+      out.examined += 1;
+      const text = readFileSync(abs, "utf8");
+      const date = fileDate(abs, text);
+      if (!date) { out.undated.push(rel(abs)); continue; }
+      const secret = secretLine(text);
+      if (secret) { out.refused.push({ path: rel(abs), why: `holds ${secret}; not copied` }); continue; }
+      const target = join(daily.abs, `${date}.md`);
+      if (existsSync(target) && readFileSync(target, "utf8").includes(marker(rel(abs)))) continue;
+      out.filings.push({ from: rel(abs), to: rel(target), date, body: stripFrontmatter(text).replace(/\n+$/, "") });
+    }
+  }
+  for (const abs of mdFiles(daily.abs)) {
+    out.examined += 1;
+    if (!fileDate(abs, readFileSync(abs, "utf8"))) out.undated.push(rel(abs));
+  }
+
+  // People a recent note mentions, whose file carries nothing from that note.
+  if (people.mapped && people.exists) {
+    const recent = [...mdFiles(daily.abs), ...(captures.mapped && captures.exists ? mdFiles(captures.abs) : [])]
+      .map((abs) => ({ abs, text: readFileSync(abs, "utf8") }))
+      .filter((f) => { const d = fileDate(f.abs, f.text); return d && d >= from; });
+    for (const p of mdFiles(people.abs)) {
+      out.examined += 1;
+      const ptext = readFileSync(p, "utf8");
+      for (const name of personNames(p, ptext)) {
+        for (const f of recent) {
+          if (!mentions(f.text, name)) continue;
+          if (ptext.includes(rel(f.abs)) || ptext.includes(basename(f.abs, ".md"))) continue;
+          if (out.people.some((x) => x.person === rel(p) && x.note === rel(f.abs))) continue;
+          out.people.push({ person: rel(p), name, note: rel(f.abs) });
+        }
+      }
+    }
+  }
+
+  // Imports: each is a claim to check with the owner over time. Recent ones are listed.
+  const imp = importsDir(evda);
+  if (existsSync(imp.abs)) {
+    for (const abs of mdFiles(imp.abs)) {
+      out.examined += 1;
+      const d = fileDate(abs, readFileSync(abs, "utf8"));
+      if (d && d >= from) out.imports.push(rel(abs));
+    }
+  }
+
+  // Notes under the record's folder that no role or the imports folder claims.
+  const claimed = resolveAll(evda).filter((r) => r.mapped && r.exists && r.isDir).map((r) => r.abs);
+  claimed.push(imp.abs);
+  const root = dirname(daily.abs);
+  if (root !== evda.dir && existsSync(root)) {
+    const walk = (d) => {
+      for (const n of readdirSync(d).sort()) {
+        if (n.startsWith(".")) continue;
+        const abs = join(d, n);
+        if (claimed.includes(abs)) continue;
+        if (statSync(abs).isDirectory()) walk(abs);
+        else if (n.endsWith(".md")) { out.examined += 1; out.unplaced.push(rel(abs)); }
+      }
+    };
+    walk(root);
+  }
+  return out;
+}
+
+export function reportText(p, { now = new Date(), window = 7 } = {}) {
+  const lines = [`## Run ${localTime(now)}`, ""];
+  lines.push(`Examined ${p.examined} note(s). Moved nothing.`, "");
+  lines.push("### Filed");
+  if (p.filings.length) for (const f of p.filings) lines.push(`- ${f.from} copied verbatim into ${f.to}`);
+  else lines.push("- Nothing new to file.");
+  lines.push("", `### People mentioned in the last ${window} days`);
+  if (p.people.length) for (const x of p.people) lines.push(`- ${x.note} mentions ${x.name}; ${x.person} has nothing from it yet.`);
+  else lines.push("- None without a note on their file.");
+  lines.push("", "### Imports to check with the owner over time");
+  if (p.imports.length) for (const i of p.imports) lines.push(`- ${i}: what another AI said, not their words.`);
+  else lines.push("- None recent.");
+  if (p.undated.length) { lines.push("", "### Undated, so not filed"); for (const u of p.undated) lines.push(`- ${u}: needs a YYYY-MM-DD at the start of its name, or a date: line.`); }
+  if (p.unplaced.length) { lines.push("", "### Under no role"); for (const u of p.unplaced) lines.push(`- ${u}: not in daily, captures, people or imports.`); }
+  if (p.refused.length) { lines.push("", "### Not copied"); for (const r of p.refused) lines.push(`- ${r.path}: ${r.why}. Keep the secret in a password manager and take it out of the note.`); }
+  lines.push("");
+  return lines.join("\n");
+}
+
+function appendReport(evda, kind, date, block) {
+  const dir = join(evda.dir, REPORTS, kind);
+  mkdirSync(dir, { recursive: true });
+  const abs = join(dir, `${date}.md`);
+  if (!existsSync(abs)) writeFileSync(abs, `# ${kind === "organize" ? "Organize" : "Look back"}, ${date}\n\nWritten by evda ${kind}. Append only; each run adds a section.\n`);
+  appendFileSync(abs, `\n${block.replace(/\n+$/, "")}\n`);
+  return posix(relative(evda.dir, abs));
+}
+
+// Run the owner's claude -p with the skill and read-only EVDA tools. Returns { ok, text, why }.
+export function askOwnersAi(evda, prompt, { model = null, env = process.env, timeoutMs = 600_000 } = {}) {
+  const bin = env.EVDA_CLAUDE || "claude";
+  const { command, args } = serverCommand(evda.dir);
+  const mcp = JSON.stringify({ mcpServers: { [SERVER_NAME]: { type: "stdio", command, args } } });
+  const allowed = ["evda_operating_layer", "evda_recent", "evda_search", "evda_circles"].map((t) => `mcp__${SERVER_NAME}__${t}`);
+  const skill = existsSync(SKILL_SOURCE) ? readFileSync(SKILL_SOURCE, "utf8") : "";
+  const argv = ["-p", prompt, "--mcp-config", mcp, "--strict-mcp-config", "--allowedTools", allowed.join(","), "--output-format", "text"];
+  if (skill) argv.push("--append-system-prompt", skill);
+  if (model) argv.push("--model", model);
+  const r = spawnSync(bin, argv, { cwd: evda.dir, env, encoding: "utf8", timeout: timeoutMs, maxBuffer: 16 * 1024 * 1024 });
+  if (r.error) return { ok: false, why: r.error.code === "ENOENT" ? `${bin} is not installed or not on PATH` : String(r.error.message) };
+  if (r.status !== 0) return { ok: false, why: `${bin} -p exited ${r.status}: ${(r.stderr || r.stdout || "").trim().split("\n").slice(-3).join(" ")}` };
+  const text = (r.stdout ?? "").trim();
+  if (!text) return { ok: false, why: `${bin} -p answered with nothing` };
+  return { ok: true, text };
+}
+
+export async function organize(evda, { now = new Date(), window = 7, withAi = false, dryRun = false, model = null, env = process.env } = {}) {
+  const p = plan(evda, { now, window });
+  const date = localDate(now);
+  let report = reportText(p, { now, window });
+  if (dryRun) return { plan: p, report, path: null, exit: 0, summary: `${report}\n(dry run: nothing was written)` };
+
+  for (const f of p.filings) {
+    const abs = join(evda.dir, f.to);
+    const head = existsSync(abs) ? "" : `# ${f.date}\n`;
+    const lead = existsSync(abs) && !readFileSync(abs, "utf8").endsWith("\n") ? "\n" : "";
+    appendFileSync(abs, `${lead}${head}\n## Capture: ${basename(f.from, ".md")}\n\n${marker(f.from)}\n\n${f.body}\n`);
+  }
+  let exit = 0;
+  if (withAi) {
+    const ai = askOwnersAi(evda, [
+      "Use the evda skill's Organizing section. Here is today's organize report for this record.",
+      "For each note that needs a place, answer in one line: the note's path, where it belongs, and the words from the note that say so, quoted.",
+      "Check against the record with the evda tools first. Write nothing. If nothing needs a place, say so in one line.",
+      "",
+      report,
+    ].join("\n"), { model, env });
+    if (ai.ok) {
+      const secret = secretLine(ai.text);
+      report += secret ? `\n### Your AI's read\n\nNot kept: the answer held ${secret}.\n` : `\n### Your AI's read (claude -p)\n\n${ai.text}\n`;
+    } else {
+      report += `\n### Your AI's read\n\nSKIPPED: ${ai.why}. Nothing else in this run depended on it.\n`;
+      exit = 1;
+    }
+  }
+  const path = appendReport(evda, "organize", date, report);
+  return { plan: p, report, path, exit, summary: `${report}\nReport appended to ${path}. Filed ${p.filings.length} capture(s).` };
+}
+
+export async function lookBack(evda, { now = new Date(), model = null, env = process.env } = {}) {
+  const ai = askOwnersAi(evda, "Use the evda skill's Look back section for the last 7 days of this record. Write nothing; your answer is appended to a report.", { model, env });
+  const date = localDate(now);
+  const block = ai.ok
+    ? (secretLine(ai.text) ? `## Run ${localTime(now)}\n\nNot kept: the answer held a secret-shaped line.\n` : `## Run ${localTime(now)}\n\n${ai.text}\n`)
+    : `## Run ${localTime(now)}\n\nSKIPPED: ${ai.why}.\n`;
+  const path = appendReport(evda, "look-back", date, block);
+  return { path, exit: ai.ok ? 0 : 1, summary: `${block}\nAppended to ${path}.` };
+}

package/lib/routines.mjs

@@ -0,0 +1,143 @@
+// Starter routines: a morning organize and a weekly look back, each optional, each scheduled only on
+// the owner's yes.
+//
+// The first choice is Claude's own scheduler. A local scheduled task in the Claude desktop app runs
+// on this machine with access to this folder (https://code.claude.com/docs/en/desktop-scheduled-tasks).
+// It is created in the app, so `evda routine` prints exactly what to put in it. A cloud routine
+// (`/schedule`) runs on a fresh clone with no access to local files, so it cannot reach a record.
+//
+// The fallback is launchd on a Mac: a job that runs `evda organize --with-ai` (or `look-back`) on a
+// calendar, through a login shell so the owner's `claude` is on PATH. `--install` writes it and
+// loads it; nothing else here schedules anything.
+
+import { mkdirSync, writeFileSync, existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { spawnSync } from "node:child_process";
+import { openEvda, holderOf } from "./manifest.mjs";
+import { serverCommand } from "./connect.mjs";
+import { EvdaError } from "./errors.mjs";
+
+export const ROUTINES = {
+  morning: {
+    id: "evda-morning-organize",
+    title: "EVÐA morning organize",
+    when: "Daily at 8:00",
+    calendar: { Hour: 8, Minute: 0 },
+    command: ["organize", "--with-ai"],
+    does: "files new captures into their day and writes a report of what belongs where. Moves nothing.",
+  },
+  weekly: {
+    id: "evda-weekly-look-back",
+    title: "EVÐA weekly look back",
+    when: "Weekly on Sunday at 18:00",
+    calendar: { Weekday: 0, Hour: 18, Minute: 0 },
+    command: ["look-back"],
+    does: "reads the week back to you in a report: what recurred in your words and what changed. No scores.",
+  },
+};
+export const ROUTINE_KEYS = Object.keys(ROUTINES);
+
+const q = (s) => (/^[A-Za-z0-9_./:@=+-]+$/.test(s) ? s : `'${String(s).replace(/'/g, "'\\''")}'`);
+
+// The shell command a routine runs, with this machine's node and this package's bin.
+export function routineCommand(key, dir) {
+  const r = ROUTINES[key];
+  const { command, args } = serverCommand(dir);
+  // serverCommand ends in `mcp <dir>`; a routine swaps that for its own command.
+  const base = [command, ...args.slice(0, -2)];
+  return [...base, r.command[0], resolve(dir), ...r.command.slice(1)].map(q).join(" ");
+}
+
+export function desktopInstructions(key, dir) {
+  const r = ROUTINES[key];
+  return [
+    `${r.title}: ${r.does}`,
+    "",
+    "In the Claude desktop app: open the Code tab, then Routines, then New routine, and choose Local.",
+    `  Name:         ${r.id}`,
+    `  Schedule:     ${r.when}`,
+    `  Folder:       ${resolve(dir)}`,
+    "  Instructions: Run this command in the folder, then tell me the report path it prints and anything it SKIPPED:",
+    `                ${routineCommand(key, dir)}`,
+    "",
+    "A local routine runs while the app is open and the computer is awake.",
+  ].join("\n");
+}
+
+export function label(key, evda) {
+  const id = (holderOf(evda).id ?? "record").replace(/[^A-Za-z0-9.-]+/g, "-");
+  return `io.evda.${ROUTINES[key].id}.${id}`;
+}
+
+const xml = (s) => String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+
+export function launchdPlist(key, dir, { home = homedir() } = {}) {
+  const evda = openEvda(dir);
+  const r = ROUTINES[key];
+  const log = join(home, "Library", "Logs", "evda", `${r.id}.log`);
+  const cal = Object.entries(r.calendar).map(([k, v]) => `      <key>${k}</key><integer>${v}</integer>`).join("\n");
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+    '<plist version="1.0">',
+    "<dict>",
+    `  <key>Label</key><string>${xml(label(key, evda))}</string>`,
+    "  <key>ProgramArguments</key>",
+    "  <array>",
+    "    <string>/bin/zsh</string>",
+    "    <string>-lc</string>",
+    `    <string>${xml(routineCommand(key, dir))}</string>`,
+    "  </array>",
+    "  <key>StartCalendarInterval</key>",
+    "  <dict>",
+    cal,
+    "  </dict>",
+    `  <key>StandardOutPath</key><string>${xml(log)}</string>`,
+    `  <key>StandardErrorPath</key><string>${xml(log)}</string>`,
+    "</dict>",
+    "</plist>",
+    "",
+  ].join("\n");
+}
+
+// Write the launchd job and load it. `agentsDir` and `load` exist so tests never touch the real
+// ~/Library/LaunchAgents or launchctl.
+export function installLaunchd(key, dir, { agentsDir = process.env.EVDA_LAUNCH_AGENTS ?? join(homedir(), "Library", "LaunchAgents"), load = process.env.EVDA_NO_LAUNCHCTL !== "1", home = homedir() } = {}) {
+  if (process.platform !== "darwin" && load) throw new EvdaError("REFUSED: launchd is macOS only. Use the Claude desktop routine instead. Nothing was written.", { exit: 2 });
+  const evda = openEvda(dir);
+  const plist = launchdPlist(key, dir, { home });
+  mkdirSync(agentsDir, { recursive: true });
+  mkdirSync(join(home, "Library", "Logs", "evda"), { recursive: true });
+  const path = join(agentsDir, `${label(key, evda)}.plist`);
+  const existed = existsSync(path);
+  writeFileSync(path, plist);
+  let loaded = "not loaded (EVDA_NO_LAUNCHCTL=1)";
+  if (load) {
+    const uid = process.getuid?.() ?? "";
+    spawnSync("launchctl", ["bootout", `gui/${uid}`, path], { encoding: "utf8" });
+    const r = spawnSync("launchctl", ["bootstrap", `gui/${uid}`, path], { encoding: "utf8" });
+    loaded = r.status === 0 ? "loaded" : `launchctl bootstrap exited ${r.status}: ${(r.stderr ?? "").trim()}`;
+  }
+  return { path, existed, loaded };
+}
+
+export function routineMain(args, { pickDir }) {
+  const key = args[0];
+  if (!ROUTINE_KEYS.includes(key)) throw new EvdaError(`usage: evda routine <${ROUTINE_KEYS.join("|")}> [dir] [--launchd] [--install]`, { exit: 2 });
+  const { dir, flags } = pickDir(args.slice(1));
+  if (flags.includes("--install")) {
+    const r = installLaunchd(key, dir);
+    console.log(`${r.existed ? "replaced" : "wrote"} ${r.path}: ${r.loaded}. ${ROUTINES[key].when}, it runs: ${routineCommand(key, dir)}`);
+    return 0;
+  }
+  if (flags.includes("--launchd")) {
+    process.stdout.write(launchdPlist(key, dir));
+    return 0;
+  }
+  console.log(desktopInstructions(key, dir));
+  console.log("");
+  console.log(`Or on a Mac without the app open: evda routine ${key} ${resolve(dir)} --install (launchd, runs ${ROUTINES[key].when.toLowerCase()}).`);
+  console.log("A scheduled job cannot read a record inside Documents, Desktop, Downloads or iCloud Drive unless the shell has Full Disk Access.");
+  return 0;
+}

package/lib/setup.mjs

@@ -69,11 +69,19 @@ export function trainingSection() {
   }).join("\n");
 }
 
-// A chat app with project instructions cannot read or write the folder. It can still be used.
-export const CHAT_APPS = [
-  "ChatGPT or Claude in the browser or app: make a Project, paste AGENTS.md into its instructions, and add your record files to it. Anything you write there stays in that app until you copy it into record/.",
+// A chat app's project instructions field cannot read or write this folder: it holds text for
+// that conversation only, and nothing persists to record/. Pasting AGENTS.md into a ChatGPT or
+// Claude Project does not run an EVDA. The Claude desktop app is different once its Filesystem
+// extension is pointed at this folder; it then reads AGENTS.md the way Claude Code does.
+export const DESKTOP_FILESYSTEM = [
+  "Claude desktop app: Settings, then Extensions, install \"Filesystem\", add this folder, and it reads AGENTS.md too.",
 ];
 
+// The prompt an owner pastes into a chat app (ChatGPT, Claude, or any AI they already talk to) to
+// pull out what it knows or has guessed about them, so it can be brought into their EVDA once as
+// an import. Plain text, nothing structured, because the answer is filed verbatim.
+export const IMPORT_PROMPT = "Write out everything you remember or have inferred about me: facts, preferences, patterns, things I've told you directly, and things you've only guessed. Plain text, as much as you have, and do not summarize it down.";
+
 // The loaders: one line that imports AGENTS.md, for the tools that do not read it on their own.
 // Codex, Cursor, Copilot, Windsurf, Zed and the others on agents.md read AGENTS.md directly and
 // need nothing.
@@ -158,6 +166,32 @@ export const WELCOME = [
   "The only requirement is that you want to, and you are open to it. Iris is the default name; call it whatever you like.",
 ].join("\n");
 
+// The setup questions, in the order they are asked. The terminal interview and the EVÐA app both
+// read them from here, so the two surfaces cannot ask different things. `agent` is the name the
+// owner chose on the first question.
+export function questions(agent = DEFAULT_AGENT_NAME) {
+  return [
+    { 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: "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:" },
+    { key: "import", text: "Bring in what your AI already knows about you?" },
+    { key: "skill", text: `Install the evda skill for Claude Code, so ${agent} works through your EVÐA from any folder?` },
+    { key: "morning", text: "Add a morning organize routine, which files your captures into their day and reports what belongs where?" },
+    { key: "weekly", text: "Add a weekly look back routine, which reads your week back to you?" },
+  ];
+}
+
+// What a yes to the import offer shows: the line before IMPORT_PROMPT and the line after it.
+export function importLines(agent = DEFAULT_AGENT_NAME) {
+  return {
+    intro: "Paste this into a new chat with ChatGPT, Claude, or whatever AI you already talk to:",
+    after: `Bring its answer to your first session with ${agent}. ${agent} files it as an import: what that AI said, not your own words, and a claim to check over time rather than a fact.`,
+  };
+}
+
 // 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.
@@ -167,13 +201,14 @@ export async function interview(opts, io) {
   out(WELCOME);
   out("");
   const a = { ...opts };
-  if (a.agentName == null) a.agentName = (await ask(`What would you like to call your agent? (${DEFAULT_AGENT_NAME}) `)) || DEFAULT_AGENT_NAME;
+  const q = (key, agent) => questions(agent).find((x) => x.key === key).text;
+  if (a.agentName == null) a.agentName = (await ask(`${q("agentName")} `)) || DEFAULT_AGENT_NAME;
   const agent = a.agentName || DEFAULT_AGENT_NAME;
-  if (!a.owner) a.owner = await ask("What is your name? ");
-  if (!a.purpose) a.purpose = await ask(`What do you want ${agent} for? Say it however it comes out. `);
-  if (!a.voice) a.voice = await ask(`How do you want ${agent} to talk to you? `);
+  if (!a.owner) a.owner = await ask(`${q("owner", agent)} `);
+  if (!a.purpose) a.purpose = await ask(`${q("purpose", agent)} `);
+  if (!a.voice) a.voice = await ask(`${q("voice", agent)} `);
   if (!a.platform) {
-    out("Which AI will you use it with?");
+    out(q("platform", agent));
     PLATFORM_KEYS.forEach((k, i) => out(`  ${i + 1}. ${PLATFORMS[k].label}`));
     let key = null;
     let raw = "";
@@ -187,7 +222,7 @@ export async function interview(opts, io) {
   const p = PLATFORMS[a.platform];
   if (!a.trainingOff) {
     out("");
-    out("Before anything personal goes in, turn model training off:");
+    out(q("trainingOff", agent));
     for (const line of p.training) out(`  ${line}`);
     if (p.url) out(`  ${p.url}`);
     let yes = false;
@@ -200,5 +235,27 @@ export async function interview(opts, io) {
   }
   out("");
   out(DICTATION);
+  out("");
+  const bring = (await ask(`${q("import", agent)} (yes/no) `)).toLowerCase();
+  if (bring === "yes" || bring === "y") {
+    const lines = importLines(agent);
+    out("");
+    out(lines.intro);
+    out("");
+    out(`  ${IMPORT_PROMPT}`);
+    out("");
+    out(lines.after);
+  }
+  const yes = async (key) => ["yes", "y"].includes((await ask(`${q(key, agent)} (yes/no) `)).toLowerCase());
+  if (a.skill == null) {
+    out("");
+    a.skill = await yes("skill");
+  }
+  if (a.routines == null) {
+    out("");
+    out("Routines are optional and nothing is scheduled without a yes. Each runs through your own AI, never an API key in EVÐA.");
+    a.routines = [];
+    for (const key of ["morning", "weekly"]) if (await yes(key)) a.routines.push(key);
+  }
   return a;
 }