digital-brain 0.1.3 → 1.0.3

package/README.md

@@ -24,7 +24,7 @@ Digital Brain gives them a structured, local map of:
 npx digital-brain init
 ```
 
-The installer asks a short setup quiz: history window, primary focus, refresh cadence, always-on interval, active time window, outbound mode, and AI adapter setup.
+The installer asks a short setup quiz: setup mode, history window, primary focus, refresh cadence, always-on interval, active time window, outbound mode, and AI adapter setup.
 
 The quiz is mostly multiple choice. Pick with `A/B/C`, `1/2/3`, the exact value, or press Enter to accept the default. If you skip the vault path, Digital Brain creates a new folder in the current directory:
 
@@ -38,7 +38,7 @@ For a non-interactive setup:
 npx digital-brain init --yes
 ```
 
-For local always-on setup:
+Inside the quiz, choose `Auto mode` to use recommended always-on local refresh settings. You can also start there directly:
 
 ```bash
 npx digital-brain init --full-auto
@@ -46,6 +46,8 @@ npx digital-brain init --full-auto
 
 Full-auto means local repeated refreshes. It does not mean blind auto-send. WhatsApp sending still defaults to drafts or explicit confirmation, and the AI-disclosure guard stays enabled.
 
+`init` also runs a setup check. npm installs the package dependencies automatically, and Digital Brain does not require pip packages. If Python or a selected source is missing, the check prints the exact next step and setup link. See [docs/SETUP.md](docs/SETUP.md).
+
 For local development:
 
 ```bash
@@ -58,6 +60,9 @@ node ./bin/digital-brain.js init ./Digital Brain\ Vault
 - An Obsidian-friendly Markdown vault.
 - AI adapter files for Codex, Claude, and Gemini.
 - WhatsApp Mac import tools.
+- Apple iMessage import tools.
+- Slack export import tools.
+- LinkedIn data archive import tools.
 - Relationship extraction and interpretation models.
 - Optional WhatsApp Web outbound sender.
 - A refresh script based on your install-time answers.
@@ -66,10 +71,15 @@ node ./bin/digital-brain.js init ./Digital Brain\ Vault
 ## What It Can Do
 
 - Import recent WhatsApp history from the local macOS WhatsApp database.
+- Import recent iMessage history from the local macOS Messages database.
+- Import Slack workspace exports.
+- Import LinkedIn data archives for connections and messages when available.
 - Build relationship profiles from message patterns.
+- Merge confirmed-looking same-person profiles across sources into a person context index.
 - Infer provisional roles like parent, family group, work collaborator, close personal contact, or unlabeled contact.
 - Extract relationship-specific typing style: casing, message length, punctuation, emoji, and slang.
 - Generate "how to continue this relationship" notes.
+- Generate reply-ready person context that keeps WhatsApp, iMessage, Slack, and LinkedIn evidence separate under the same person.
 - Create AI-readable memory files for future prompts.
 - Draft WhatsApp sends by default, and only send with explicit `--yes`.
 - Enforce an AI-disclosure guard after repeated AI-assisted sends.
@@ -77,11 +87,28 @@ node ./bin/digital-brain.js init ./Digital Brain\ Vault
 ## Core Commands
 
 ```bash
-digital-brain init ./Digital Brain\ Vault
-digital-brain sync-whatsapp --vault ./Digital Brain\ Vault --days 30
-digital-brain extract --vault ./Digital Brain\ Vault --days 30
-digital-brain interpret --vault ./Digital Brain\ Vault --days 30
-digital-brain send-whatsapp --vault ./Digital Brain\ Vault --to "Name" --message "text"
+digital-brain init
+digital-brain run
+digital-brain doctor
+digital-brain sync-imessage --days 30
+digital-brain import-slack --input ./slack-export.zip
+digital-brain import-linkedin --input ./linkedin-archive.zip
+digital-brain send-whatsapp --to "Name" --message "text"
+```
+
+`init` remembers your vault globally, so `run` works from anywhere. `run` syncs the live local sources you selected, extracts relationships, and writes interpreted memory in one command.
+
+Slack and LinkedIn are import-based. Digital Brain reads official export archives; it does not scrape LinkedIn or automate private app UIs. See [docs/INTEGRATIONS.md](docs/INTEGRATIONS.md).
+
+Use `digital-brain doctor` or `digital-brain tutorial` anytime to see dependency status and next steps.
+
+The lower-level commands still exist for debugging:
+
+```bash
+digital-brain sync-whatsapp
+digital-brain sync-imessage
+digital-brain extract
+digital-brain interpret
 ```
 
 The sender drafts by default. Add `--yes` to actually send.
@@ -132,6 +159,10 @@ Digital Brain is local-first. It does not upload messages or notes.
 
 WhatsApp support reads the local macOS WhatsApp database when available. This is experimental and unofficial. Outbound messaging uses WhatsApp Web through `whatsapp-web.js`.
 
+Apple iMessage support reads the local macOS Messages `chat.db` when available. If the database is missing or inaccessible and iMessage was selected, `digital-brain run` fails with a clear setup error instead of silently skipping it.
+
+Slack support reads Slack workspace export JSON. LinkedIn support reads LinkedIn data archive CSV files when LinkedIn includes the relevant files in your archive.
+
 Relationship labels are working notes, not truth. You can edit them with `relationship_overrides.json`.
 
 Always-on and outbound modes depend on local app databases, WhatsApp Web, and third-party behavior that can change. You are responsible for consent, privacy, message content, and anything sent from your machine.

package/bin/digital-brain.js

@@ -5,9 +5,10 @@ import os from "node:os";
 import path from "node:path";
 import readline from "node:readline/promises";
 import { fileURLToPath } from "node:url";
-import { copyDir, ensureDir, packageRoot, resolveVault } from "../lib/fs.js";
+import { copyDir, ensureDir, packageRoot, resolveVault, writeDefaultVault } from "../lib/fs.js";
 
 const root = packageRoot(import.meta.url);
+const CONFIG_SCHEMA_VERSION = 1;
 
 main().catch((error) => {
   console.error(error.message);
@@ -19,8 +20,13 @@ async function main() {
   const args = parseArgs(argv);
 
   if (command === "init") await init(argv, args);
+  else if (command === "run" || command === "refresh") runRefresh(argv, args);
   else if (command === "doctor") doctor();
+  else if (command === "tutorial" || command === "setup-check") doctor({ tutorial: true });
   else if (command === "sync-whatsapp") runPython("digital_brain_whatsapp_mac_sync.py", argv);
+  else if (command === "sync-imessage") runPython("digital_brain_imessage_sync.py", argv);
+  else if (command === "import-slack") runPython("digital_brain_slack_export_import.py", argv);
+  else if (command === "import-linkedin") runPython("digital_brain_linkedin_export_import.py", argv);
   else if (command === "extract") runPython("digital_brain_relationship_extractor.py", argv);
   else if (command === "interpret") runPython("digital_brain_relationship_interpreter.py", argv);
   else if (command === "send-whatsapp") runNode("whatsapp-web/send.mjs", argv);
@@ -31,6 +37,7 @@ async function init(argv, args) {
   const positional = argv.filter((arg) => !arg.startsWith("--"));
   const defaultVault = path.resolve(process.cwd(), "Digital Brain Vault");
   const fullAuto = toBoolean(args["full-auto"]);
+  let setupMode = fullAuto ? "full-auto" : "guided";
   let vault = positional[0] ? path.resolve(positional[0]) : args.yes ? defaultVault : "";
   let selfName = args["self-name"] || "";
   let connectAi = toBoolean(args["connect-ai"]);
@@ -41,6 +48,9 @@ async function init(argv, args) {
   let activeWindow = args["active-window"] || "08:00-12:00";
   let timezone = args.timezone || Intl.DateTimeFormat().resolvedOptions().timeZone || "local";
   let outboundMode = args["outbound-mode"] || "draft";
+  let privacyMode = args["privacy-mode"] || "standard";
+  let sourceMarkdownMode = args["source-markdown-mode"] || "none";
+  let selectedSources = parseList(args.sources || "whatsapp");
   let responsibilityAccepted = fullAuto || schedule === "always-on";
 
   if (!args.yes) {
@@ -49,18 +59,28 @@ async function init(argv, args) {
     vault ||= path.resolve(await ask(rl, "📁 Vault path", defaultVault, "Enter creates this folder if it does not exist."));
     selfName ||= await ask(rl, "👤 Your name", "Me");
     dataWindowDays = await askNumber(rl, "🕰️  History to import", dataWindowDays, { suffix: "days", min: 1 });
+    setupMode = await select(rl, "Setup mode", [
+      ["guided", "Guided", "Pick each setting yourself.", "🧭"],
+      ["full-auto", "Auto mode", "Use recommended always-on local refresh settings.", "⚡"],
+    ], setupMode);
     focus ||= await select(rl, "Primary focus", [
       ["relationship-memory", "Relationship memory", "Map people, tone, and recurring patterns.", "🧠"],
       ["reply-help", "Reply help", "Prioritize drafting guidance and typing-style matching.", "💬"],
       ["work-context", "Work context", "Prioritize collaborators, projects, and operational notes.", "💼"],
     ], "relationship-memory");
-    schedule = await select(rl, "Refresh cadence", [
-      ["manual", "Manual", "Only runs when you run a command.", "🖐️"],
-      ["daily", "Daily", "Good for a low-maintenance personal vault.", "🌅"],
-      ["hourly", "Hourly", "Keeps memory warm without running constantly.", "⏱️"],
-      ["every-30-min", "Every 30 minutes", "Useful for morning or work-window guidance.", "🔁"],
-      ["always-on", "Always-on local loop", "Runs repeatedly while your computer is awake.", "⚡"],
-    ], schedule);
+    if (setupMode === "full-auto") {
+      schedule = "always-on";
+      console.log("");
+      console.log("⚡ Auto mode selected: always-on local refresh, draft-first outbound, AI disclosure guard enabled.");
+    } else {
+      schedule = await select(rl, "Refresh cadence", [
+        ["manual", "Manual", "Only runs when you run a command.", "🖐️"],
+        ["daily", "Daily", "Good for a low-maintenance personal vault.", "🌅"],
+        ["hourly", "Hourly", "Keeps memory warm without running constantly.", "⏱️"],
+        ["every-30-min", "Every 30 minutes", "Useful for morning or work-window guidance.", "🔁"],
+        ["always-on", "Always-on local loop", "Runs repeatedly while your computer is awake.", "⚡"],
+      ], schedule);
+    }
     if (schedule === "always-on") {
       refreshIntervalMinutes = await askNumber(rl, "⏳ Always-on pull interval", refreshIntervalMinutes, {
         suffix: "minutes",
@@ -68,6 +88,16 @@ async function init(argv, args) {
       });
     }
     activeWindow = await ask(rl, "🪟 Active window for frequent refreshes", activeWindow);
+    selectedSources = await multiSelect(rl, "Sources to set up", [
+      ["whatsapp", "WhatsApp Mac", "Live local sync from WhatsApp for Mac database.", "💚"],
+      ["imessage", "Apple iMessage", "Live local sync from macOS Messages database.", "💬"],
+      ["slack", "Slack export", "Import official Slack workspace export ZIP/folder.", "🧵"],
+      ["linkedin", "LinkedIn archive", "Import official LinkedIn data archive ZIP/folder.", "💼"],
+    ], selectedSources);
+    privacyMode = await select(rl, "Privacy mode", [
+      ["standard", "Standard", "Keep raw JSONL locally for analysis, but do not generate raw chat Markdown.", "🔐"],
+      ["metadata-only", "Metadata only", "Store timestamps and participants, but omit message bodies.", "🧼"],
+    ], privacyMode);
     outboundMode = await select(rl, "WhatsApp outbound mode", [
       ["disabled", "Disabled", "Never prepares WhatsApp sends.", "🔒"],
       ["draft", "Draft only", "Prepares text and requires you to send it.", "✍️"],
@@ -79,6 +109,7 @@ async function init(argv, args) {
       console.log("Full-auto/outbound confirmation was not accepted. Using manual refresh and draft-only outbound.");
       schedule = "manual";
       outboundMode = "draft";
+      setupMode = "guided";
     }
     rl.close();
   }
@@ -86,6 +117,7 @@ async function init(argv, args) {
   ensureDir(vault);
   copyDir(path.join(root, "templates", "vault"), vault);
   const config = {
+    schemaVersion: CONFIG_SCHEMA_VERSION,
     selfName: selfName || "Me",
     dataWindowDays,
     focus: focus || "relationship-memory",
@@ -94,7 +126,11 @@ async function init(argv, args) {
     activeWindow,
     timezone,
     outboundMode,
-    setupMode: fullAuto ? "full-auto" : "guided",
+    privacyMode,
+    sourceMarkdownMode,
+    selectedSources,
+    outboundLogMode: args["outbound-log-mode"] || "metadata",
+    setupMode,
     responsibilityAccepted,
     defaults: {
       enterUsesDefault: true,
@@ -109,6 +145,7 @@ async function init(argv, args) {
     },
   };
   writeConfig(vault, config);
+  writeDefaultVault(vault);
   writeRefreshScript(vault, config);
   writeWatchScript(vault, config);
 
@@ -120,47 +157,207 @@ async function init(argv, args) {
 
   console.log(`Digital Brain vault created: ${vault}`);
   console.log(`Config: ${path.join(vault, "digital-brain.config.json")}`);
+  console.log(`Default vault saved: ${vault}`);
   console.log(`Refresh script: ${path.join(vault, "Tools", "digital-brain-refresh.sh")}`);
   console.log(`Always-on script: ${path.join(vault, "Tools", "digital-brain-watch.sh")}`);
   console.log("Next:");
-  console.log(`  digital-brain sync-whatsapp --vault "${vault}" --days ${dataWindowDays}`);
-  console.log(`  digital-brain extract --vault "${vault}" --days ${dataWindowDays}`);
-  console.log(`  digital-brain interpret --vault "${vault}" --days ${dataWindowDays}`);
+  console.log("  digital-brain run");
   if (schedule === "always-on") console.log(`  "${path.join(vault, "Tools", "digital-brain-watch.sh")}"`);
+  printSetupCheck(vault, { tutorial: true });
 }
 
-function doctor() {
-  const checks = [
-    ["node", process.version],
-    ["python3", shell("python3", ["--version"])],
-    ["sqlite3", shell("sqlite3", ["--version"])],
-    ["ollama", shell("ollama", ["--version"], true)],
-  ];
-  for (const [name, value] of checks) {
-    console.log(`${name}: ${value || "not found"}`);
-  }
-  const macDb = path.join(os.homedir(), "Library/Group Containers/group.net.whatsapp.WhatsApp.shared/ChatStorage.sqlite");
-  console.log(`WhatsApp Mac DB: ${fs.existsSync(macDb) ? macDb : "not found"}`);
+function doctor(options = {}) {
+  printSetupCheck(resolveVault(process.cwd()), options);
 }
 
 function runPython(script, argv) {
-  const resolved = withVault(argv);
-  const result = spawnSync("python3", [path.join(root, "scripts", script), ...resolved], { stdio: "inherit" });
+  const result = runPythonStep(script, withVault(argv));
   process.exit(result.status ?? 1);
 }
 
+function runRefresh(argv, args) {
+  const vault = getVaultFromArgs(argv);
+  const config = readVaultConfig(vault);
+  const days = String(args.days || args["data-window-days"] || config.dataWindowDays || 30);
+  const markdownMode = args["markdown-mode"] || config.sourceMarkdownMode || "none";
+  const privacyMode = args["privacy-mode"] || config.privacyMode || "standard";
+  const selectedSources = parseList(args.sources || "").length ? parseList(args.sources) : config.selectedSources || ["whatsapp"];
+  const syncArgs = ["--vault", vault, "--days", days, "--markdown-mode", markdownMode, "--privacy-mode", privacyMode];
+  const extractArgs = ["--vault", vault, "--days", days];
+  const interpretArgs = ["--vault", vault, "--days", days];
+  if (args["min-messages"]) extractArgs.push("--min-messages", String(args["min-messages"]));
+  console.log(`Digital Brain refresh: ${vault}`);
+  if (toBoolean(args["dry-run"])) {
+    console.log("Dry run. Planned steps:");
+    if (selectedSources.includes("whatsapp")) console.log(`  sync WhatsApp: days=${days}, markdown=${markdownMode}, privacy=${privacyMode}`);
+    if (selectedSources.includes("imessage")) console.log(`  sync iMessage: days=${days}, markdown=${markdownMode}, privacy=${privacyMode}`);
+    if (selectedSources.includes("slack")) console.log("  Slack: import-only; run digital-brain import-slack --input <export.zip>");
+    if (selectedSources.includes("linkedin")) console.log("  LinkedIn: import-only; run digital-brain import-linkedin --input <archive.zip>");
+    console.log(`  extract relationships: days=${days}`);
+    console.log(`  interpret relationship drafts: days=${days}`);
+    return;
+  }
+  const steps = [];
+  if (selectedSources.includes("whatsapp")) steps.push(["sync WhatsApp", "sync-whatsapp", "digital_brain_whatsapp_mac_sync.py", syncArgs]);
+  if (selectedSources.includes("imessage")) steps.push(["sync iMessage", "sync-imessage", "digital_brain_imessage_sync.py", syncArgs]);
+  steps.push(
+    ["extract", "extract", "digital_brain_relationship_extractor.py", extractArgs],
+    ["interpret", "interpret", "digital_brain_relationship_interpreter.py", interpretArgs],
+  );
+  for (const [label, skipKey, script, stepArgs] of steps) {
+    const skipRequested = toBoolean(args[`skip-${skipKey}`]) || (skipKey.startsWith("sync-") && toBoolean(args["skip-sync"]));
+    if (skipRequested) {
+      console.log(`\n→ ${label} skipped`);
+      continue;
+    }
+    console.log(`\n→ ${label}`);
+    const result = runPythonStep(script, stepArgs);
+    if ((result.status ?? 1) !== 0) process.exit(result.status ?? 1);
+  }
+  console.log("\nDigital Brain refresh complete.");
+}
+
+function runPythonStep(script, argv) {
+  return spawnSync("python3", [path.join(root, "scripts", script), ...argv], { stdio: "inherit" });
+}
+
 function runNode(script, argv) {
-  const result = spawnSync(process.execPath, [path.join(root, script), ...argv], { stdio: "inherit" });
+  const result = spawnSync(process.execPath, [path.join(root, script), ...withVault(argv)], { stdio: "inherit" });
   process.exit(result.status ?? 1);
 }
 
 function withVault(argv) {
   if (argv.includes("--vault") || argv.some((arg) => arg.startsWith("--vault="))) return argv;
-  return ["--vault", resolveVault(process.cwd()), ...argv];
+  return ["--vault", getVaultFromArgs(argv), ...argv];
+}
+
+function getVaultFromArgs(argv) {
+  const args = parseArgs(argv);
+  if (args.vault) return path.resolve(String(args.vault));
+  return resolveVault(process.cwd());
+}
+
+function readVaultConfig(vault) {
+  const file = path.join(vault, "digital-brain.config.json");
+  if (!fs.existsSync(file)) {
+    console.error(`No Digital Brain vault found. Run "digital-brain init" first, or pass --vault <path>.`);
+    process.exit(1);
+  }
+  return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+
+function printSetupCheck(vault, options = {}) {
+  const config = fs.existsSync(path.join(vault, "digital-brain.config.json")) ? readVaultConfig(vault) : {};
+  const selectedSources = config.selectedSources || ["whatsapp"];
+  const pythonVersion = shell("python3", ["--version"], true);
+  const pythonSqlite = shell("python3", ["-c", "import sqlite3; print('ok')"], true);
+  const ollamaVersion = shell("ollama", ["--version"], true);
+  const macDb = path.join(os.homedir(), "Library/Group Containers/group.net.whatsapp.WhatsApp.shared/ChatStorage.sqlite");
+  const messagesDb = path.join(os.homedir(), "Library/Messages/chat.db");
+  const checks = [
+    {
+      label: "Node",
+      ok: nodeMajor() >= 20,
+      value: process.version,
+      hint: "Install Node 20 or newer from https://nodejs.org.",
+    },
+    {
+      label: "Package dependencies",
+      ok: true,
+      value: "installed by npm",
+    },
+    {
+      label: "Python 3",
+      ok: Boolean(pythonVersion),
+      value: pythonVersion || "not found",
+      hint: "Install with: brew install python",
+    },
+    {
+      label: "Python sqlite3",
+      ok: pythonSqlite === "ok",
+      value: pythonSqlite === "ok" ? "available" : "not found",
+      hint: "Use a Python 3 build with sqlite3 support.",
+    },
+    {
+      label: "Ollama",
+      ok: Boolean(ollamaVersion),
+      value: ollamaVersion || "optional",
+      hint: "Optional local LLM: brew install ollama",
+      optional: true,
+    },
+  ];
+  if (selectedSources.includes("whatsapp")) {
+    checks.push({
+      label: "WhatsApp Mac database",
+      ok: fs.existsSync(macDb),
+      value: fs.existsSync(macDb) ? "found" : "not found yet",
+      hint: "Install/open WhatsApp for Mac, log in, then grant Terminal Full Disk Access if needed: https://faq.whatsapp.com/686469079565350",
+    });
+  }
+  if (selectedSources.includes("imessage")) {
+    checks.push({
+      label: "Apple Messages database",
+      ok: fs.existsSync(messagesDb),
+      value: fs.existsSync(messagesDb) ? "found" : "not found yet",
+      hint: "Open Messages on macOS and grant Terminal Full Disk Access if needed: https://support.apple.com/guide/messages/welcome/mac",
+    });
+  }
+  if (selectedSources.includes("slack")) {
+    checks.push({
+      label: "Slack export",
+      ok: true,
+      value: "import manually",
+      hint: "Export guide: https://slack.com/help/articles/201658943-Export-your-workspace-data",
+    });
+  }
+  if (selectedSources.includes("linkedin")) {
+    checks.push({
+      label: "LinkedIn archive",
+      ok: true,
+      value: "import manually",
+      hint: "Export guide: https://www.linkedin.com/help/linkedin/answer/a566336",
+    });
+  }
+
+  console.log("");
+  console.log("Setup check");
+  for (const check of checks) {
+    const icon = check.ok ? "✓" : check.optional ? "○" : "!";
+    console.log(`  ${icon} ${check.label}: ${check.value}`);
+    if (!check.ok && check.hint) console.log(`    ${check.hint}`);
+  }
+  if (fs.existsSync(path.join(vault, "digital-brain.config.json"))) {
+    console.log(`  ✓ Default vault: ${vault}`);
+  } else {
+    console.log("  ! Default vault: not set");
+    console.log("    Run: digital-brain init");
+  }
+
+  if (options.tutorial) {
+    console.log("");
+    console.log("How to use it");
+    let step = 1;
+    if (selectedSources.includes("whatsapp")) {
+      console.log(`  ${step++}. Open WhatsApp for Mac once and keep it logged in.`);
+    }
+    if (selectedSources.includes("imessage")) {
+      console.log(`  ${step++}. Open Messages on macOS once and grant Terminal Full Disk Access if needed.`);
+    }
+    if (selectedSources.includes("slack")) {
+      console.log(`  ${step++}. Download a Slack export, then run: digital-brain import-slack --input <export.zip>`);
+    }
+    if (selectedSources.includes("linkedin")) {
+      console.log(`  ${step++}. Download a LinkedIn archive, then run: digital-brain import-linkedin --input <archive.zip>`);
+    }
+    console.log(`  ${step++}. Run: digital-brain run`);
+    console.log(`  ${step}. Ask your AI to use the generated vault notes for personal context.`);
+    console.log("");
+    console.log("No pip install is needed. npm installs the package dependencies.");
+  }
 }
 
 function writeConfig(vault, config) {
-  fs.writeFileSync(path.join(vault, "digital-brain.config.json"), `${JSON.stringify(config, null, 2)}\n`);
+  writeFileAtomic(path.join(vault, "digital-brain.config.json"), `${JSON.stringify(config, null, 2)}\n`);
 }
 
 function writeRefreshScript(vault, config) {
@@ -173,14 +370,12 @@ set -euo pipefail
 VAULT="${vault.replace(/"/g, '\\"')}"
 DAYS="${days}"
 
-digital-brain sync-whatsapp --vault "$VAULT" --days "$DAYS" --markdown-mode month
-digital-brain extract --vault "$VAULT" --days "$DAYS"
-digital-brain interpret --vault "$VAULT" --days "$DAYS"
+digital-brain run --vault "$VAULT" --days "$DAYS"
 
 echo "Digital Brain refresh complete for $VAULT"
 `;
   const scriptPath = path.join(toolsDir, "digital-brain-refresh.sh");
-  fs.writeFileSync(scriptPath, content);
+  writeFileAtomic(scriptPath, content);
   fs.chmodSync(scriptPath, 0o755);
 }
 
@@ -203,7 +398,7 @@ while true; do
 done
 `;
   const scriptPath = path.join(toolsDir, "digital-brain-watch.sh");
-  fs.writeFileSync(scriptPath, content);
+  writeFileAtomic(scriptPath, content);
   fs.chmodSync(scriptPath, 0o755);
 }
 
@@ -224,6 +419,12 @@ Use it as local personal context when the user asks about preferences, relations
   console.log(`${label} pointer: ${file}`);
 }
 
+function writeFileAtomic(file, content) {
+  const temp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(temp, content);
+  fs.renameSync(temp, file);
+}
+
 function printSetupHeader(defaultVault) {
   console.log("");
   console.log("╭────────────────────────────────────────╮");
@@ -271,6 +472,28 @@ async function select(rl, label, options, fallback) {
   return exact ? exact[0] : options[defaultIndex][0];
 }
 
+async function multiSelect(rl, label, options, fallbackValues) {
+  const fallback = fallbackValues.length ? fallbackValues : [options[0][0]];
+  console.log("");
+  console.log(`◇ ${label}`);
+  options.forEach(([, title, description, icon = "•"], index) => {
+    const selected = fallback.includes(options[index][0]) ? "  ← default" : "";
+    const letter = letterFor(index);
+    console.log(`  ${letter}) ${icon}  ${title}${selected}`);
+    console.log(`     ${description}`);
+  });
+  const answer = await rl.question(`Choose one or more, comma-separated [${fallback.join(",")}]: `);
+  if (!answer.trim()) return fallback;
+  const values = [];
+  for (const token of answer.split(",").map((value) => value.trim()).filter(Boolean)) {
+    const letterIndex = indexFromLetter(token);
+    const numericIndex = Number(token) - 1;
+    const option = options[letterIndex] || options[numericIndex] || options.find(([value, title]) => value === token || title.toLowerCase() === token.toLowerCase());
+    if (option && !values.includes(option[0])) values.push(option[0]);
+  }
+  return values.length ? values : fallback;
+}
+
 async function confirm(rl, label, fallback) {
   const hint = fallback ? "Y/n" : "y/N";
   const answer = (await rl.question(`${label} [${hint}]: `)).trim().toLowerCase();
@@ -306,6 +529,10 @@ function shell(command, args, optional = false) {
   return (result.stdout || result.stderr).trim().split("\n")[0];
 }
 
+function nodeMajor() {
+  return Number(process.version.replace(/^v/, "").split(".")[0]);
+}
+
 function parseArgs(argv) {
   const out = {};
   for (let i = 0; i < argv.length; i += 1) {
@@ -324,6 +551,11 @@ function parseArgs(argv) {
   return out;
 }
 
+function parseList(value) {
+  if (!value) return [];
+  return String(value).split(",").map((item) => item.trim()).filter(Boolean);
+}
+
 function toBoolean(value) {
   if (value === undefined) return false;
   if (value === true) return true;
@@ -341,10 +573,15 @@ function help() {
 
 Usage:
   digital-brain init [vault]
+  digital-brain run
   digital-brain doctor
-  digital-brain sync-whatsapp --vault <path> --days 30
-  digital-brain extract --vault <path> --days 30
-  digital-brain interpret --vault <path> --days 30
-  digital-brain send-whatsapp --vault <path> --to "Name" --message "Text" [--yes]
+  digital-brain tutorial
+  digital-brain sync-whatsapp --days 30
+  digital-brain sync-imessage --days 30
+  digital-brain import-slack --input slack-export.zip
+  digital-brain import-linkedin --input linkedin-archive.zip
+  digital-brain extract --days 30
+  digital-brain interpret --days 30
+  digital-brain send-whatsapp --to "Name" --message "Text" [--yes]
 `);
 }

package/docs/AUTOMATIONS.md

@@ -10,6 +10,14 @@ Tools/digital-brain-refresh.sh
 
 That script runs sync, extract, and interpret using the install-time config.
 
+After setup, the normal manual command is:
+
+```bash
+digital-brain run
+```
+
+`init` saves your default vault in `~/.digital-brain/config.json`, so `run` does not need a vault path.
+
 ## Configurable At Install
 
 `digital-brain init` asks:
@@ -17,6 +25,7 @@ That script runs sync, extract, and interpret using the install-time config.
 - vault path
 - your name
 - history window in days
+- setup mode: guided or auto mode
 - primary focus: relationship memory, reply help, work context
 - refresh cadence: manual, daily, hourly, every 30 minutes, or always-on
 - refresh interval in minutes for always-on mode, clamped to a minimum of 1
@@ -44,15 +53,15 @@ The answers are saved in:
 digital-brain.config.json
 ```
 
-## Full Auto
+## Auto Mode
 
-Use:
+Choose `Auto mode` during `digital-brain init`, or use:
 
 ```bash
 digital-brain init --full-auto
 ```
 
-Full-auto configures local always-on refreshes with a 5 minute default interval. It still uses the local watch script, so it only runs while the machine and runner are awake.
+Auto mode configures local always-on refreshes with a 5 minute default interval. It still uses the local watch script, so it only runs while the machine and runner are awake.
 
 During the guided quiz, always-on and send-with-confirmation require an explicit responsibility check. Pressing Enter does not approve that check. If it is skipped, Digital Brain falls back to manual refresh and draft-only outbound.
 
@@ -63,7 +72,7 @@ Use a Codex cron automation pointed at the generated vault.
 Prompt:
 
 ```text
-Run `Tools/digital-brain-refresh.sh`. Verify completion and report only counts plus output paths. Do not print private message contents.
+Run `digital-brain run`. Verify completion and report only counts plus output paths. Do not print private message contents.
 ```
 
 Example schedule ideas: