@datacore-one/cli 1.0.6 → 1.0.8

package/dist/index.js

@@ -6980,727 +6980,1162 @@ var require_dist = __commonJS((exports) => {
   exports.visitAsync = visit.visitAsync;
 });
 
-// src/lib/agent.ts
-var exports_agent = {};
-__export(exports_agent, {
-  listAgents: () => listAgents,
-  invokeAgent: () => invokeAgent,
-  agentExists: () => agentExists
+// src/lib/space.ts
+var exports_space = {};
+__export(exports_space, {
+  listSpaces: () => listSpaces,
+  getSpace: () => getSpace,
+  getNextSpaceNumber: () => getNextSpaceNumber,
+  createSpace: () => createSpace,
+  auditSpace: () => auditSpace
 });
-import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync9 } from "fs";
-import { join as join9 } from "path";
-function commandExists2(cmd) {
-  try {
-    const { execSync: execSync6 } = __require("child_process");
-    execSync6(`which ${cmd}`, { stdio: "pipe" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function invokeAgent(invocation, options = {}) {
-  const { stream = false, cwd = DATA_DIR7, timeout = 300000 } = options;
-  if (!commandExists2("claude")) {
-    return {
-      success: false,
-      output: "",
-      error: "Claude Code CLI not found. Install with: npm install -g @anthropic-ai/claude-code"
-    };
-  }
-  if (!existsSync9(cwd)) {
-    return {
-      success: false,
-      output: "",
-      error: `Working directory not found: ${cwd}`
-    };
+import { existsSync as existsSync3, readdirSync, statSync, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3, basename } from "path";
+function listSpaces() {
+  if (!existsSync3(DATA_DIR2)) {
+    return [];
   }
-  const prompt2 = buildAgentPrompt(invocation);
-  return new Promise((resolve) => {
-    const chunks = [];
-    let errorChunks = [];
-    let timedOut = false;
-    const proc = spawn2("claude", ["--print", prompt2], {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: {
-        ...process.env,
-        CI: "true"
-      }
-    });
-    const timer = setTimeout(() => {
-      timedOut = true;
-      proc.kill("SIGTERM");
-    }, timeout);
-    proc.stdout?.on("data", (data) => {
-      const text = data.toString();
-      chunks.push(text);
-      if (stream) {
-        process.stdout.write(text);
-      }
-    });
-    proc.stderr?.on("data", (data) => {
-      errorChunks.push(data.toString());
-    });
-    proc.on("close", (code) => {
-      clearTimeout(timer);
-      const output2 = chunks.join("");
-      const stderr = errorChunks.join("");
-      if (timedOut) {
-        resolve({
-          success: false,
-          output: output2,
-          error: `Agent timed out after ${timeout}ms`
-        });
-        return;
-      }
-      if (code !== 0) {
-        resolve({
-          success: false,
-          output: output2,
-          error: stderr || `Agent exited with code ${code}`
-        });
-        return;
-      }
-      const artifacts = parseArtifacts(output2);
-      resolve({
-        success: true,
-        output: output2,
-        artifacts: Object.keys(artifacts).length > 0 ? artifacts : undefined
-      });
-    });
-    proc.on("error", (err) => {
-      clearTimeout(timer);
-      resolve({
-        success: false,
-        output: chunks.join(""),
-        error: err.message
-      });
+  const entries = readdirSync(DATA_DIR2, { withFileTypes: true });
+  const spaces = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    const match = entry.name.match(/^(\d+)-(.+)$/);
+    if (!match)
+      continue;
+    const [, numStr, name] = match;
+    const number = parseInt(numStr, 10);
+    const path = join3(DATA_DIR2, entry.name);
+    spaces.push({
+      name: entry.name,
+      number,
+      path,
+      type: number === 0 ? "personal" : "team",
+      hasGit: existsSync3(join3(path, ".git")),
+      hasClaude: existsSync3(join3(path, "CLAUDE.md")) || existsSync3(join3(path, "CLAUDE.base.md"))
     });
-  });
-}
-function buildAgentPrompt(invocation) {
-  const { agent, params } = invocation;
-  const paramLines = Object.entries(params).map(([key, value]) => `- ${key}: ${JSON.stringify(value)}`).join(`
-`);
-  return `Use the Task tool to invoke the "${agent}" agent with the following parameters:
-
-${paramLines || "(no parameters)"}
-
-Wait for the agent to complete and return its results.`;
-}
-function parseArtifacts(output2) {
-  const artifacts = {};
-  const regex = /<!-- ARTIFACT:([^:]+):([^ ]+) -->/g;
-  let match;
-  while ((match = regex.exec(output2)) !== null) {
-    const [, name, path] = match;
-    if (name && path) {
-      artifacts[name] = path;
-    }
   }
-  return artifacts;
+  spaces.sort((a, b) => a.number - b.number);
+  return spaces;
 }
-function listAgents() {
-  const registryPath = join9(DATA_DIR7, ".datacore", "registry", "agents.yaml");
-  if (!existsSync9(registryPath)) {
-    return [];
-  }
-  try {
-    const { readFileSync: readFileSync5 } = __require("fs");
-    const { parse: parse3 } = require_dist();
-    const content = readFileSync5(registryPath, "utf-8");
-    const registry = parse3(content);
-    return registry.agents?.map((a) => a.name) || [];
-  } catch {
-    return [];
-  }
+function getSpace(nameOrNumber) {
+  const spaces = listSpaces();
+  if (typeof nameOrNumber === "number") {
+    return spaces.find((s) => s.number === nameOrNumber) || null;
+  }
+  let space = spaces.find((s) => s.name === nameOrNumber);
+  if (space)
+    return space;
+  space = spaces.find((s) => s.name.includes(nameOrNumber));
+  return space || null;
 }
-function agentExists(name) {
-  return listAgents().includes(name);
+function getNextSpaceNumber() {
+  const spaces = listSpaces();
+  if (spaces.length === 0)
+    return 0;
+  const maxNumber = Math.max(...spaces.map((s) => s.number));
+  return maxNumber + 1;
 }
-var DATA_DIR7;
-var init_agent = __esm(() => {
-  DATA_DIR7 = join9(process.env.HOME || "~", "Data");
-});
-
-// src/routing.ts
-var RESOURCES = ["space", "module", "config", "nightshift", "cron", "snapshot"];
-var META_COMMANDS = [
-  "init",
-  "doctor",
-  "ingest",
-  "sync",
-  "today",
-  "tomorrow",
-  "version"
-];
-var ACTIONS = {
-  space: ["create", "list"],
-  module: ["install", "list", "update", "remove"],
-  config: ["show", "get", "set"],
-  nightshift: ["status", "trigger", "queue"],
-  cron: ["install", "status", "remove"],
-  snapshot: ["create", "restore", "diff", "show"]
-};
-function parseArgs(argv) {
-  if (argv.length === 0) {
-    return { type: "help", topic: undefined, subtopic: undefined };
-  }
-  const [first, ...rest] = argv;
-  if (!first) {
-    return { type: "help", topic: undefined, subtopic: undefined };
-  }
-  const helpIndex = argv.findIndex((a) => a === "--help" || a === "-h");
-  if (helpIndex !== -1) {
-    if (helpIndex === 0) {
-      return { type: "help", topic: undefined, subtopic: undefined };
-    }
-    if (helpIndex === 1 && RESOURCES.includes(first)) {
-      return { type: "help", topic: first, subtopic: undefined };
-    }
-    if (helpIndex === 2 && RESOURCES.includes(first)) {
-      return { type: "help", topic: first, subtopic: rest[0] };
-    }
-    return { type: "help", topic: first, subtopic: undefined };
-  }
-  if (first === "--version" || first === "-v") {
-    return { type: "meta", command: "version", args: [], flags: {} };
+function createSpace(name, type = "team") {
+  const number = type === "personal" ? 0 : getNextSpaceNumber();
+  const normalizedName = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  const folderName = `${number}-${normalizedName}`;
+  const spacePath = join3(DATA_DIR2, folderName);
+  if (existsSync3(spacePath)) {
+    throw new Error(`Space already exists: ${folderName}`);
   }
-  if (first === "help") {
-    return { type: "help", topic: rest[0], subtopic: rest[1] };
+  mkdirSync2(spacePath, { recursive: true });
+  const dirs = type === "personal" ? [
+    ".datacore",
+    ".datacore/commands",
+    ".datacore/agents",
+    ".datacore/learning",
+    ".datacore/state",
+    ".datacore/env",
+    "org",
+    "0-inbox",
+    "notes",
+    "notes/journals",
+    "notes/pages",
+    "notes/zettel",
+    "journal",
+    "3-knowledge",
+    "3-knowledge/pages",
+    "3-knowledge/zettel",
+    "3-knowledge/literature",
+    "3-knowledge/reference",
+    "4-archive",
+    "content"
+  ] : [
+    ".datacore",
+    ".datacore/commands",
+    ".datacore/agents",
+    ".datacore/learning",
+    ".datacore/state",
+    ".datacore/env",
+    "org",
+    "0-inbox",
+    "journal",
+    "1-tracks",
+    "1-tracks/ops",
+    "1-tracks/product",
+    "1-tracks/dev",
+    "1-tracks/research",
+    "1-tracks/comms",
+    "2-projects",
+    "3-knowledge",
+    "3-knowledge/pages",
+    "3-knowledge/zettel",
+    "3-knowledge/literature",
+    "3-knowledge/reference",
+    "4-archive"
+  ];
+  for (const dir of dirs) {
+    mkdirSync2(join3(spacePath, dir), { recursive: true });
   }
-  if (META_COMMANDS.includes(first)) {
-    const { args, flags } = parseRest(rest);
-    return { type: "meta", command: first, args, flags };
-  }
-  if (RESOURCES.includes(first)) {
-    const action = rest[0] || "list";
-    const { args, flags } = parseRest(rest.slice(1));
-    return { type: "resource", resource: first, action, args, flags };
-  }
-  return { type: "unknown", command: first };
-}
-function parseRest(argv) {
-  const args = [];
-  const flags = {};
-  for (let i = 0;i < argv.length; i++) {
-    const arg = argv[i];
-    if (!arg)
-      continue;
-    if (arg.startsWith("--")) {
-      if (arg.includes("=")) {
-        const [key, value] = arg.slice(2).split("=");
-        if (key)
-          flags[key] = value ?? true;
-      } else {
-        const key = arg.slice(2);
-        const next = argv[i + 1];
-        if (next && !next.startsWith("-")) {
-          flags[key] = next;
-          i++;
-        } else {
-          flags[key] = true;
-        }
-      }
-    } else if (arg.startsWith("-") && arg.length === 2) {
-      const key = arg.slice(1);
-      flags[key] = true;
-    } else {
-      args.push(arg);
-    }
-  }
-  return { args, flags };
-}
-function suggestCommand(unknown) {
-  const allCommands = [...META_COMMANDS, ...RESOURCES];
-  for (const cmd of allCommands) {
-    if (cmd.startsWith(unknown) || unknown.startsWith(cmd)) {
-      return cmd;
-    }
-    if (Math.abs(cmd.length - unknown.length) <= 1) {
-      let diff = 0;
-      for (let i = 0;i < Math.max(cmd.length, unknown.length); i++) {
-        if (cmd[i] !== unknown[i])
-          diff++;
-      }
-      if (diff <= 2)
-        return cmd;
-    }
-  }
-  return null;
-}
-
-// src/help.ts
-function showHelp() {
-  console.log(`datacore - AI Second Brain Setup & Management CLI
+  if (type === "personal") {
+    writeFileSync2(join3(spacePath, "org", "inbox.org"), `#+TITLE: Inbox
+#+FILETAGS: :inbox:
 
-Setup and admin tool for Datacore. For daily use, run: cd ~/Data && claude
+Capture everything here. Process daily to zero.
 
-Usage:
-  datacore <command> [args] [options]
+* TODO Do more. With less.
+* Inbox
+`);
+    writeFileSync2(join3(spacePath, "org", "next_actions.org"), `#+TITLE: Next Actions
+#+TODO: TODO NEXT WAITING | DONE CANCELED
+#+FILETAGS: :tasks:
 
-Setup:
-  init                 Set up a new Datacore installation
-  doctor               Check dependencies and system status
-  ingest <path>        Import files during setup
+Tasks organized by focus area. Tag with :AI: to delegate to agents.
 
-Admin:
-  space                Create and list spaces
-  module               Install and manage modules
-  snapshot             Create/restore installation snapshots
-  config               View and modify settings
+* TIER 1: STRATEGIC FOUNDATION
+** /Projects
+** /Work
+* TIER 2: SUPPORTING WORK
+** Admin
+** Maintenance
+* PERSONAL: LIFE & DEVELOPMENT
+** /Personal Development
+** /Health & Longevity
+** Home & Family
+** Financial Management
+* RESEARCH & LEARNING
+** Technology
+** Skills
+`);
+    writeFileSync2(join3(spacePath, "org", "nightshift.org"), `#+TITLE: Nightshift Queue
+#+TODO: QUEUED EXECUTING | DONE FAILED
+#+FILETAGS: :nightshift:
 
-Automation (for cron jobs):
-  sync                 Sync all git repos
-  today                Generate daily briefing
-  tomorrow             End-of-day wrap-up
-  nightshift           Queue and trigger AI tasks
-  cron                 Set up scheduled tasks
+AI tasks queued for overnight execution. Managed by /tomorrow command.
 
-Meta:
-  version              Show version
-  help [topic]         Show help for a topic
+* Queue
+`);
+    writeFileSync2(join3(spacePath, "org", "habits.org"), `#+TITLE: Habits
+#+FILETAGS: :habits:
 
-Options:
-  --format json|human  Output format (auto-detects TTY)
-  --help, -h           Show help for any command
-  --yes, -y            Skip confirmation prompts
+Recurring behaviors and routines. Track with org-habit.
 
-Examples:
-  # Initial setup
-  datacore init
-  datacore ingest ~/Documents/chatgpt-export/
+* Daily
+* Weekly
+* Monthly
+`);
+    writeFileSync2(join3(spacePath, "org", "someday.org"), `#+TITLE: Someday/Maybe
+#+FILETAGS: :someday:
 
-  # Admin
-  datacore snapshot create
-  datacore module install nightshift
+Ideas and projects for the future. Review monthly.
 
-  # Then use Claude Code for daily workflow
-  cd ~/Data && claude`);
-}
-function showResourceHelp(resource) {
-  if (resource === "init") {
-    showInitHelp();
-    return;
-  }
-  if (resource === "doctor") {
-    showDoctorHelp();
-    return;
-  }
-  if (resource === "ingest") {
-    showIngestHelp();
-    return;
-  }
-  if (resource === "sync") {
-    showSyncHelp();
-    return;
-  }
-  if (resource === "today" || resource === "tomorrow") {
-    showGtdMetaHelp(resource);
-    return;
-  }
-  if (!RESOURCES.includes(resource)) {
-    console.log(`Unknown command: ${resource}
+* Someday
+* Maybe
+`);
+    writeFileSync2(join3(spacePath, "org", "archive.org"), `#+TITLE: Archive
+#+FILETAGS: :archive:
 
-Available commands: init, doctor, ingest, sync, today, tomorrow, space, module, config, nightshift, cron, snapshot
+Completed and canceled tasks. Searchable history.
 
-Run 'datacore help' for overview.`);
-    return;
-  }
-  const actions = ACTIONS[resource];
-  console.log(`datacore ${resource} - ${getResourceDescription(resource)}
+* Archived Tasks
+`);
+  } else {
+    writeFileSync2(join3(spacePath, "org", "inbox.org"), `#+TITLE: Inbox
+#+FILETAGS: :inbox:
 
-Usage:
-  datacore ${resource} <action> [args] [options]
+* Capture items here
+`);
+    writeFileSync2(join3(spacePath, "org", "next_actions.org"), `#+TITLE: Next Actions
+#+FILETAGS: :tasks:
 
-Actions:`);
-  for (const action of actions) {
-    console.log(`  ${action.padEnd(18)} ${getActionDescription(resource, action)}`);
+* Tasks
+** TODO items go here
+`);
   }
-  console.log(`
-For detailed help on an action:
-  datacore ${resource} <action> --help
-  datacore help ${resource} <action>`);
-}
-function showInitHelp() {
-  console.log(`datacore init - Set up a new Datacore installation
+  if (type === "personal") {
+    writeFileSync2(join3(spacePath, "_index.md"), `# Personal Space
 
-Usage:
-  datacore init [options]
+Your personal knowledge base and GTD system.
 
-Description:
-  Interactive wizard that sets up your Datacore second brain:
-  1. Creates ~/Data directory structure
-  2. Initializes git repositories
-  3. Generates CLAUDE.md context files
-  4. Creates personal space (0-personal)
-  5. Optionally installs recommended modules
+## GTD Workflow
 
-Options:
-  --path <dir>         Installation directory (default: ~/Data)
-  --yes, -y            Use defaults, skip prompts
-  --no-claude          Skip Claude Code check
+1. **Capture** → \`org/inbox.org\` - dump everything here
+2. **Clarify** → Is it actionable? What's the next action?
+3. **Organize** → Move to \`next_actions.org\` by focus area
+4. **Reflect** → Weekly review, monthly strategic
+5. **Engage** → Do the work, delegate with :AI: tags
 
-Examples:
-  # Interactive setup
-  datacore init
+## Org Files (GTD)
 
-  # Non-interactive with defaults
-  datacore init --yes
+| File | Purpose |
+|------|---------|
+| [inbox.org](org/inbox.org) | Single capture point - process to zero daily |
+| [next_actions.org](org/next_actions.org) | Active tasks by focus area |
+| [nightshift.org](org/nightshift.org) | AI task queue (overnight processing) |
+| [habits.org](org/habits.org) | Recurring behaviors |
+| [someday.org](org/someday.org) | Future possibilities |
+| [archive.org](org/archive.org) | Completed/canceled tasks |
 
-  # Custom location
-  datacore init --path ~/my-data`);
-}
-function showDoctorHelp() {
-  console.log(`datacore doctor - Check dependencies and system status
+## Knowledge
 
-Usage:
-  datacore doctor [options]
+| Folder | Purpose |
+|--------|---------|
+| [notes/](notes/) | Personal knowledge base (Obsidian) |
+| [notes/journals/](notes/journals/) | Daily personal journals |
+| [3-knowledge/](3-knowledge/) | Structured knowledge (zettelkasten) |
 
-Description:
-  Verifies all required dependencies are installed and checks
-  the health of your Datacore installation.
+## Other
 
-Checks:
-  Required:
-    - git          Version control
-    - git-lfs      Large file support
-    - node >= 18   Node.js runtime
-    - python >= 3.9 Python runtime
-
-  Recommended:
-    - claude       Claude Code CLI for AI features
+- [journal/](journal/) - AI session journals (auto-generated)
+- [content/](content/) - Generated content (drafts, emails)
+- [0-inbox/](0-inbox/) - File inbox (process files here)
+- [4-archive/](4-archive/) - Historical content
+`);
+  } else {
+    writeFileSync2(join3(spacePath, "_index.md"), `# ${name}
 
-  Datacore:
-    - ~/Data exists
-    - .datacore/ configured
-    - Spaces detected
+Team space.
 
-Options:
-  --format json    Output as JSON
+## Structure
 
-Examples:
-  datacore doctor
-  datacore doctor --format json`);
-}
-function showIngestHelp() {
-  console.log(`datacore ingest - Import files with AI processing
+- \`org/\` - Task coordination
+- \`1-tracks/\` - Department work
+- \`2-projects/\` - Code repositories
+- \`3-knowledge/\` - Shared knowledge
+- \`4-archive/\` - Historical content
 
-Usage:
-  datacore ingest <path> [options]
+## Quick Links
 
-Description:
-  Imports files into Datacore with deep knowledge extraction.
-  The CLI validates paths and invokes the ingest-coordinator agent
-  which handles the 6-phase semantic processing:
+- [Inbox](org/inbox.org)
+- [Tasks](org/next_actions.org)
+- [Journal](journal/)
+- [Knowledge](3-knowledge/)
+`);
+  }
+  if (type === "personal") {
+    writeFileSync2(join3(spacePath, "CLAUDE.base.md"), `# Personal Space
 
-  1. READ    - Analyze content
-  2. ASSESS  - Determine destination
-  3. EXTRACT - Pull out knowledge (zettels, insights)
-  4. CAPTURE - Log tasks and TODOs
-  5. FILE    - Move to semantic location
-  6. LINK    - Connect to knowledge graph
+Personal GTD system and knowledge base (per DIP-0009).
 
-Options:
-  --space <name>   Target space (default: 0-personal)
-  --dry-run        Show what would happen without doing it
+## GTD Files
 
-Examples:
-  # Import a file
-  datacore ingest ~/Documents/report.pdf
+| File | Purpose | Process |
+|------|---------|---------|
+| \`org/inbox.org\` | Single capture point | Process to zero daily |
+| \`org/next_actions.org\` | Active tasks by focus area | Work from here |
+| \`org/nightshift.org\` | AI task queue | Auto-managed by /tomorrow |
+| \`org/habits.org\` | Recurring behaviors | Track daily |
+| \`org/someday.org\` | Future possibilities | Review monthly |
+| \`org/archive.org\` | Completed tasks | Searchable history |
 
-  # Import a folder
-  datacore ingest ~/Documents/export/
+## Task States
 
-  # Target specific space
-  datacore ingest ~/Documents/contracts/ --space 1-datafund`);
-}
-function showSyncHelp() {
-  console.log(`datacore sync - Git sync for all repos
+| State | Meaning |
+|-------|---------|
+| \`TODO\` | Standard next action |
+| \`NEXT\` | High priority, work today |
+| \`WAITING\` | Blocked on external |
+| \`DONE\` | Completed (terminal) |
+| \`CANCELED\` | Will not do (terminal) |
 
-Usage:
-  datacore sync [action] [options]
+## AI Delegation
 
-Actions:
-  (none)           Pull all repos (default)
-  push             Commit and push changes
-  status           Show git status overview
+Tag tasks with \`:AI:\` to delegate to agents:
 
-Description:
-  Manages git synchronization for the root Datacore repo
-  and all space repositories.
+| Tag | Agent | Autonomous |
+|-----|-------|------------|
+| \`:AI:content:\` | gtd-content-writer | Yes |
+| \`:AI:research:\` | gtd-research-processor | Yes |
+| \`:AI:data:\` | gtd-data-analyzer | Yes |
+| \`:AI:pm:\` | gtd-project-manager | Yes |
 
-Options:
-  --message <msg>  Commit message (for push)
+## Knowledge Structure
 
-Examples:
-  # Pull latest changes
-  datacore sync
+| Location | Purpose |
+|----------|---------|
+| \`notes/\` | Personal knowledge base (Obsidian) |
+| \`notes/journals/\` | Daily personal reflections |
+| \`3-knowledge/zettel/\` | Atomic concept notes |
+| \`3-knowledge/literature/\` | Source summaries |
 
-  # Push changes
-  datacore sync push --message "Daily update"
+## Daily Workflow
 
-  # Check status
-  datacore sync status`);
-}
-function showGtdMetaHelp(command) {
-  if (command === "today") {
-    console.log(`datacore today - Generate daily briefing
+1. **Morning** - Run \`/today\` for briefing
+2. **Capture** - Everything to inbox.org
+3. **Process** - Clear inbox, route tasks
+4. **Work** - Focus on NEXT items
+5. **Evening** - Run \`/tomorrow\` for wrap-up
 
-Usage:
-  datacore today [options]
+## See Also
 
-Description:
-  Generates your daily briefing by invoking the /today command.
-  Includes:
-  - Calendar events
-  - Priority tasks
-  - Nightshift results (completed AI tasks)
-  - Journal entry
+Parent: ~/Data/CLAUDE.md
+`);
+  } else {
+    writeFileSync2(join3(spacePath, "CLAUDE.base.md"), `# ${name} Space
 
-Options:
-  --format json    Output as JSON
+Team space for ${name}.
 
-Examples:
-  datacore today`);
-  } else {
-    console.log(`datacore tomorrow - End-of-day wrap-up
+## Structure
 
-Usage:
-  datacore tomorrow [options]
+See parent CLAUDE.md for full documentation.
+`);
+  }
+  writeFileSync2(join3(spacePath, ".datacore", "config.yaml"), `# Space configuration
+name: ${normalizedName}
+type: ${type}
+`);
+  writeFileSync2(join3(spacePath, ".datacore", "learning", "patterns.md"), `# Patterns
 
-Description:
-  Wraps up your day by invoking the /tomorrow command.
-  Includes:
-  - Session summary
-  - Queuing AI tasks for overnight
-  - Learning extraction
-  - Journal update
+Successful approaches to remember.
+`);
+  writeFileSync2(join3(spacePath, ".datacore", "learning", "corrections.md"), `# Corrections
 
-Options:
-  --format json    Output as JSON
+Human feedback log.
+`);
+  writeFileSync2(join3(spacePath, ".datacore", "learning", "preferences.md"), `# Preferences
 
-Examples:
-  datacore tomorrow`);
-  }
+Style and preference notes.
+`);
+  writeFileSync2(join3(spacePath, ".gitignore"), type === "personal" ? `.datacore/state/
+.datacore/env/
+CLAUDE.md
+CLAUDE.local.md
+` : `.datacore/state/
+.datacore/env/
+CLAUDE.md
+CLAUDE.local.md
+2-projects/
+`);
+  return {
+    name: folderName,
+    number,
+    path: spacePath,
+    type,
+    hasGit: false,
+    hasClaude: true
+  };
 }
-function showActionHelp(resource, action) {
-  if (!RESOURCES.includes(resource)) {
-    console.log(`Unknown resource: ${resource}`);
-    return;
+function auditSpace(nameOrPath) {
+  let spacePath;
+  let spaceName;
+  if (existsSync3(nameOrPath) && statSync(nameOrPath).isDirectory()) {
+    spacePath = nameOrPath;
+    spaceName = basename(nameOrPath);
+  } else {
+    const space = getSpace(nameOrPath);
+    if (!space) {
+      throw new Error(`Space not found: ${nameOrPath}`);
+    }
+    spacePath = space.path;
+    spaceName = space.name;
   }
-  const actions = ACTIONS[resource];
-  if (!actions.includes(action)) {
-    console.log(`Unknown action: ${action} for ${resource}
-
-Available actions: ${actions.join(", ")}`);
-    return;
+  const issues = [];
+  const requiredDirs = [
+    ".datacore",
+    "org",
+    "0-inbox",
+    "journal"
+  ];
+  for (const dir of requiredDirs) {
+    if (!existsSync3(join3(spacePath, dir))) {
+      issues.push({
+        type: "missing",
+        path: dir,
+        message: `Required directory missing: ${dir}`
+      });
+    }
   }
-  const help = getDetailedHelp(resource, action);
-  console.log(help);
-}
-function getResourceDescription(resource) {
-  const descriptions = {
-    space: "Create and list spaces",
-    module: "Install and manage modules",
-    config: "View and modify settings",
-    nightshift: "Queue and trigger AI tasks",
-    cron: "Manage scheduled tasks",
-    snapshot: "Create and restore installation snapshots"
+  const requiredFiles = [
+    "org/inbox.org",
+    "org/next_actions.org"
+  ];
+  for (const file of requiredFiles) {
+    if (!existsSync3(join3(spacePath, file))) {
+      issues.push({
+        type: "missing",
+        path: file,
+        message: `Required file missing: ${file}`
+      });
+    }
+  }
+  const recommendedDirs = [
+    "1-tracks",
+    "2-projects",
+    "3-knowledge",
+    "4-archive",
+    ".datacore/learning"
+  ];
+  for (const dir of recommendedDirs) {
+    if (!existsSync3(join3(spacePath, dir))) {
+      issues.push({
+        type: "warning",
+        path: dir,
+        message: `Recommended directory missing: ${dir}`
+      });
+    }
+  }
+  if (!existsSync3(join3(spacePath, "CLAUDE.base.md")) && !existsSync3(join3(spacePath, "CLAUDE.md"))) {
+    issues.push({
+      type: "warning",
+      path: "CLAUDE.base.md",
+      message: "No CLAUDE context file found"
+    });
+  }
+  let status = "healthy";
+  if (issues.some((i) => i.type === "error" || i.type === "missing")) {
+    status = "errors";
+  } else if (issues.some((i) => i.type === "warning")) {
+    status = "warnings";
+  }
+  return {
+    space: spaceName,
+    path: spacePath,
+    issues,
+    status
   };
-  return descriptions[resource];
 }
-function getActionDescription(resource, action) {
-  const descriptions = {
-    "space create": "Create a new space",
-    "space list": "List all spaces",
-    "module install": "Install a module",
-    "module list": "List installed modules",
-    "module update": "Update all modules",
-    "module remove": "Remove a module",
-    "config show": "Show all settings",
-    "config get": "Get a setting value",
-    "config set": "Set a setting value",
-    "nightshift status": "Show queue and server status",
-    "nightshift trigger": "Execute queued AI tasks",
-    "nightshift queue": "Add task to AI queue",
-    "cron install": "Install scheduled jobs",
-    "cron status": "Show job status",
-    "cron remove": "Remove scheduled jobs",
-    "snapshot create": "Create installation snapshot",
-    "snapshot restore": "Restore from snapshot",
-    "snapshot diff": "Compare with snapshot",
-    "snapshot show": "Show snapshot contents"
-  };
-  return descriptions[`${resource} ${action}`] ?? action;
+var DATA_DIR2;
+var init_space = __esm(() => {
+  DATA_DIR2 = join3(process.env.HOME || "~", "Data");
+});
+
+// src/lib/agent.ts
+var exports_agent = {};
+__export(exports_agent, {
+  listAgents: () => listAgents,
+  invokeAgent: () => invokeAgent,
+  agentExists: () => agentExists
+});
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync6 } from "fs";
+import { join as join6 } from "path";
+function commandExists2(cmd) {
+  try {
+    const { execSync: execSync4 } = __require("child_process");
+    execSync4(`which ${cmd}`, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
 }
-function getDetailedHelp(resource, action) {
-  const key = `${resource} ${action}`;
-  const helpTexts = {
-    "space create": `datacore space create - Create a new space
+async function invokeAgent(invocation, options = {}) {
+  const { stream = false, cwd = DATA_DIR5, timeout = 300000 } = options;
+  if (!commandExists2("claude")) {
+    return {
+      success: false,
+      output: "",
+      error: "Claude Code CLI not found. Install with: npm install -g @anthropic-ai/claude-code"
+    };
+  }
+  if (!existsSync6(cwd)) {
+    return {
+      success: false,
+      output: "",
+      error: `Working directory not found: ${cwd}`
+    };
+  }
+  const prompt = buildAgentPrompt(invocation);
+  return new Promise((resolve) => {
+    const chunks = [];
+    let errorChunks = [];
+    let timedOut = false;
+    const proc = spawn2("claude", ["--print", prompt], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        CI: "true"
+      }
+    });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      proc.kill("SIGTERM");
+    }, timeout);
+    proc.stdout?.on("data", (data) => {
+      const text = data.toString();
+      chunks.push(text);
+      if (stream) {
+        process.stdout.write(text);
+      }
+    });
+    proc.stderr?.on("data", (data) => {
+      errorChunks.push(data.toString());
+    });
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      const output2 = chunks.join("");
+      const stderr = errorChunks.join("");
+      if (timedOut) {
+        resolve({
+          success: false,
+          output: output2,
+          error: `Agent timed out after ${timeout}ms`
+        });
+        return;
+      }
+      if (code !== 0) {
+        resolve({
+          success: false,
+          output: output2,
+          error: stderr || `Agent exited with code ${code}`
+        });
+        return;
+      }
+      const artifacts = parseArtifacts(output2);
+      resolve({
+        success: true,
+        output: output2,
+        artifacts: Object.keys(artifacts).length > 0 ? artifacts : undefined
+      });
+    });
+    proc.on("error", (err) => {
+      clearTimeout(timer);
+      resolve({
+        success: false,
+        output: chunks.join(""),
+        error: err.message
+      });
+    });
+  });
+}
+function buildAgentPrompt(invocation) {
+  const { agent, params } = invocation;
+  const paramLines = Object.entries(params).map(([key, value]) => `- ${key}: ${JSON.stringify(value)}`).join(`
+`);
+  return `Use the Task tool to invoke the "${agent}" agent with the following parameters:
 
-Usage:
-  datacore space create [options]
+${paramLines || "(no parameters)"}
 
-Description:
-  Interactive wizard to create a new team or personal space.
-  Invokes the create-space agent for semantic decisions.
+Wait for the agent to complete and return its results.`;
+}
+function parseArtifacts(output2) {
+  const artifacts = {};
+  const regex = /<!-- ARTIFACT:([^:]+):([^ ]+) -->/g;
+  let match;
+  while ((match = regex.exec(output2)) !== null) {
+    const [, name, path] = match;
+    if (name && path) {
+      artifacts[name] = path;
+    }
+  }
+  return artifacts;
+}
+function listAgents() {
+  const registryPath = join6(DATA_DIR5, ".datacore", "registry", "agents.yaml");
+  if (!existsSync6(registryPath)) {
+    return [];
+  }
+  try {
+    const { readFileSync: readFileSync3 } = __require("fs");
+    const { parse: parse2 } = require_dist();
+    const content = readFileSync3(registryPath, "utf-8");
+    const registry = parse2(content);
+    return registry.agents?.map((a) => a.name) || [];
+  } catch {
+    return [];
+  }
+}
+function agentExists(name) {
+  return listAgents().includes(name);
+}
+var DATA_DIR5;
+var init_agent = __esm(() => {
+  DATA_DIR5 = join6(process.env.HOME || "~", "Data");
+});
 
-Options:
-  --name <name>    Space name (lowercase, hyphenated)
-  --type <type>    Space type: team or personal
-  --yes, -y        Use defaults
+// src/routing.ts
+var RESOURCES = ["space", "module", "config", "nightshift", "cron", "snapshot"];
+var META_COMMANDS = [
+  "init",
+  "doctor",
+  "ingest",
+  "sync",
+  "today",
+  "tomorrow",
+  "version"
+];
+var ACTIONS = {
+  space: ["create", "list"],
+  module: ["install", "list", "update", "remove"],
+  config: ["show", "get", "set"],
+  nightshift: ["status", "trigger", "queue"],
+  cron: ["install", "status", "remove"],
+  snapshot: ["create", "restore", "diff", "show"]
+};
+function parseArgs(argv) {
+  if (argv.length === 0) {
+    return { type: "help", topic: undefined, subtopic: undefined };
+  }
+  const [first, ...rest] = argv;
+  if (!first) {
+    return { type: "help", topic: undefined, subtopic: undefined };
+  }
+  const helpIndex = argv.findIndex((a) => a === "--help" || a === "-h");
+  if (helpIndex !== -1) {
+    if (helpIndex === 0) {
+      return { type: "help", topic: undefined, subtopic: undefined };
+    }
+    if (helpIndex === 1 && RESOURCES.includes(first)) {
+      return { type: "help", topic: first, subtopic: undefined };
+    }
+    if (helpIndex === 2 && RESOURCES.includes(first)) {
+      return { type: "help", topic: first, subtopic: rest[0] };
+    }
+    return { type: "help", topic: first, subtopic: undefined };
+  }
+  if (first === "--version" || first === "-v") {
+    return { type: "meta", command: "version", args: [], flags: {} };
+  }
+  if (first === "help") {
+    return { type: "help", topic: rest[0], subtopic: rest[1] };
+  }
+  if (META_COMMANDS.includes(first)) {
+    const { args, flags } = parseRest(rest);
+    return { type: "meta", command: first, args, flags };
+  }
+  if (RESOURCES.includes(first)) {
+    const action = rest[0] || "list";
+    const { args, flags } = parseRest(rest.slice(1));
+    return { type: "resource", resource: first, action, args, flags };
+  }
+  return { type: "unknown", command: first };
+}
+function parseRest(argv) {
+  const args = [];
+  const flags = {};
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg)
+      continue;
+    if (arg.startsWith("--")) {
+      if (arg.includes("=")) {
+        const [key, value] = arg.slice(2).split("=");
+        if (key)
+          flags[key] = value ?? true;
+      } else {
+        const key = arg.slice(2);
+        const next = argv[i + 1];
+        if (next && !next.startsWith("-")) {
+          flags[key] = next;
+          i++;
+        } else {
+          flags[key] = true;
+        }
+      }
+    } else if (arg.startsWith("-") && arg.length === 2) {
+      const key = arg.slice(1);
+      flags[key] = true;
+    } else {
+      args.push(arg);
+    }
+  }
+  return { args, flags };
+}
+function suggestCommand(unknown) {
+  const allCommands = [...META_COMMANDS, ...RESOURCES];
+  for (const cmd of allCommands) {
+    if (cmd.startsWith(unknown) || unknown.startsWith(cmd)) {
+      return cmd;
+    }
+    if (Math.abs(cmd.length - unknown.length) <= 1) {
+      let diff = 0;
+      for (let i = 0;i < Math.max(cmd.length, unknown.length); i++) {
+        if (cmd[i] !== unknown[i])
+          diff++;
+      }
+      if (diff <= 2)
+        return cmd;
+    }
+  }
+  return null;
+}
 
-Examples:
-  datacore space create
-  datacore space create --name fds --type team`,
-    "space list": `datacore space list - List all spaces
+// src/help.ts
+function showHelp() {
+  console.log(`datacore - AI Second Brain Setup & Management CLI
 
-Usage:
-  datacore space list [options]
+Setup and admin tool for Datacore. For daily use, run: cd ~/Data && claude
 
-Description:
-  Lists all spaces in your Datacore installation.
+Usage:
+  datacore <command> [args] [options]
 
-Options:
-  --format json    Output as JSON
+Setup:
+  init                 Set up a new Datacore installation
+  doctor               Check dependencies and system status
+  ingest <path>        Import files during setup
 
-Examples:
-  datacore space list`,
-    "module install": `datacore module install - Install a module
+Admin:
+  space                Create and list spaces
+  module               Install and manage modules
+  snapshot             Create/restore installation snapshots
+  config               View and modify settings
 
-Usage:
-  datacore module install <name> [options]
+Automation (for cron jobs):
+  sync                 Sync all git repos
+  today                Generate daily briefing
+  tomorrow             End-of-day wrap-up
+  nightshift           Queue and trigger AI tasks
+  cron                 Set up scheduled tasks
 
-Description:
-  Clones a module from the Datacore catalog and registers
-  its agents and commands.
+Meta:
+  version              Show version
+  help [topic]         Show help for a topic
 
-Arguments:
-  <name>           Module name (e.g., nightshift)
+Options:
+  --format json|human  Output format (auto-detects TTY)
+  --help, -h           Show help for any command
+  --yes, -y            Skip confirmation prompts
 
 Examples:
+  # Initial setup
+  datacore init
+  datacore ingest ~/Documents/chatgpt-export/
+
+  # Admin
+  datacore snapshot create
   datacore module install nightshift
-  datacore module install crm`,
-    "module list": `datacore module list - List modules
 
-Usage:
-  datacore module list [options]
+  # Then use Claude Code for daily workflow
+  cd ~/Data && claude`);
+}
+function showResourceHelp(resource) {
+  if (resource === "init") {
+    showInitHelp();
+    return;
+  }
+  if (resource === "doctor") {
+    showDoctorHelp();
+    return;
+  }
+  if (resource === "ingest") {
+    showIngestHelp();
+    return;
+  }
+  if (resource === "sync") {
+    showSyncHelp();
+    return;
+  }
+  if (resource === "today" || resource === "tomorrow") {
+    showGtdMetaHelp(resource);
+    return;
+  }
+  if (!RESOURCES.includes(resource)) {
+    console.log(`Unknown command: ${resource}
 
-Description:
-  Shows installed modules and available modules from catalog.
+Available commands: init, doctor, ingest, sync, today, tomorrow, space, module, config, nightshift, cron, snapshot
 
-Options:
-  --available      Show only available (not installed)
-  --format json    Output as JSON
+Run 'datacore help' for overview.`);
+    return;
+  }
+  const actions = ACTIONS[resource];
+  console.log(`datacore ${resource} - ${getResourceDescription(resource)}
 
-Examples:
-  datacore module list
-  datacore module list --available`,
-    "config show": `datacore config show - Show all settings
+Usage:
+  datacore ${resource} <action> [args] [options]
+
+Actions:`);
+  for (const action of actions) {
+    console.log(`  ${action.padEnd(18)} ${getActionDescription(resource, action)}`);
+  }
+  console.log(`
+For detailed help on an action:
+  datacore ${resource} <action> --help
+  datacore help ${resource} <action>`);
+}
+function showInitHelp() {
+  console.log(`datacore init - Set up a new Datacore installation
 
 Usage:
-  datacore config show [options]
+  datacore init [options]
 
 Description:
-  Displays merged configuration from base and local settings.
+  Interactive wizard that sets up your Datacore second brain:
+  1. Creates ~/Data directory structure
+  2. Initializes git repositories
+  3. Generates CLAUDE.md context files
+  4. Creates personal space (0-personal)
+  5. Optionally installs recommended modules
 
 Options:
-  --format json    Output as JSON
+  --path <dir>         Installation directory (default: ~/Data)
+  --yes, -y            Use defaults, skip prompts
+  --no-claude          Skip Claude Code check
 
 Examples:
-  datacore config show`,
-    "config get": `datacore config get - Get a setting value
-
-Usage:
-  datacore config get <key>
+  # Interactive setup
+  datacore init
 
-Arguments:
-  <key>            Setting key (e.g., sync.pull_on_today)
+  # Non-interactive with defaults
+  datacore init --yes
 
-Examples:
-  datacore config get sync.pull_on_today
-  datacore config get editor.open_command`,
-    "config set": `datacore config set - Set a setting value
+  # Custom location
+  datacore init --path ~/my-data`);
+}
+function showDoctorHelp() {
+  console.log(`datacore doctor - Check dependencies and system status
 
 Usage:
-  datacore config set <key> <value>
+  datacore doctor [options]
 
 Description:
-  Updates settings.local.yaml with the new value.
-
-Arguments:
-  <key>            Setting key
-  <value>          New value
+  Verifies all required dependencies are installed and checks
+  the health of your Datacore installation.
 
-Examples:
-  datacore config set sync.pull_on_today false
-  datacore config set editor.open_command code`,
-    "nightshift status": `datacore nightshift status - Queue and server status
+Checks:
+  Required:
+    - git          Version control
+    - git-lfs      Large file support
+    - node >= 18   Node.js runtime
+    - python >= 3.9 Python runtime
 
-Usage:
-  datacore nightshift status [options]
+  Recommended:
+    - claude       Claude Code CLI for AI features
 
-Description:
-  Shows nightshift queue summary and server connection status.
+  Datacore:
+    - ~/Data exists
+    - .datacore/ configured
+    - Spaces detected
 
 Options:
   --format json    Output as JSON
 
 Examples:
-  datacore nightshift status`,
-    "nightshift trigger": `datacore nightshift trigger - Execute queued AI tasks
+  datacore doctor
+  datacore doctor --format json`);
+}
+function showIngestHelp() {
+  console.log(`datacore ingest - Import files with AI processing
 
 Usage:
-  datacore nightshift trigger
+  datacore ingest <path> [options]
 
 Description:
-  Manually triggers execution of queued AI tasks.
-  Normally called by cron job at night.
+  Imports files into Datacore with deep knowledge extraction.
+  The CLI validates paths and invokes the ingest-coordinator agent
+  which handles the 6-phase semantic processing:
 
-Examples:
-  datacore nightshift trigger`,
-    "nightshift queue": `datacore nightshift queue - Add task to AI queue
+  1. READ    - Analyze content
+  2. ASSESS  - Determine destination
+  3. EXTRACT - Pull out knowledge (zettels, insights)
+  4. CAPTURE - Log tasks and TODOs
+  5. FILE    - Move to semantic location
+  6. LINK    - Connect to knowledge graph
 
-Usage:
-  datacore nightshift queue "<task description>"
+Options:
+  --space <name>   Target space (default: 0-personal)
+  --dry-run        Show what would happen without doing it
 
-Description:
-  Quick way to add an AI task without editing org files.
-  Adds entry to inbox.org with :AI: tag.
+Examples:
+  # Import a file
+  datacore ingest ~/Documents/report.pdf
 
-Arguments:
-  <task>           Task description
+  # Import a folder
+  datacore ingest ~/Documents/export/
 
-Examples:
-  datacore nightshift queue "Research competitor analysis"
-  datacore nightshift queue "Generate weekly metrics report"`,
-    "cron install": `datacore cron install - Install scheduled jobs
+  # Target specific space
+  datacore ingest ~/Documents/contracts/ --space 1-datafund`);
+}
+function showSyncHelp() {
+  console.log(`datacore sync - Git sync for all repos
 
 Usage:
-  datacore cron install [options]
+  datacore sync [action] [options]
+
+Actions:
+  (none)           Pull all repos (default)
+  push             Commit and push changes
+  status           Show git status overview
 
 Description:
-  Sets up platform-specific scheduled tasks:
-  - macOS: launchd plist
-  - Linux: crontab entry
+  Manages git synchronization for the root Datacore repo
+  and all space repositories.
 
 Options:
-  --schedule <cron>  Custom schedule (default: nightly)
+  --message <msg>  Commit message (for push)
 
 Examples:
-  datacore cron install
-  datacore cron install --schedule "0 2 * * *"`,
-    "snapshot create": `datacore snapshot create - Create installation snapshot
+  # Pull latest changes
+  datacore sync
+
+  # Push changes
+  datacore sync push --message "Daily update"
+
+  # Check status
+  datacore sync status`);
+}
+function showGtdMetaHelp(command) {
+  if (command === "today") {
+    console.log(`datacore today - Generate daily briefing
 
 Usage:
-  datacore snapshot create [path] [options]
+  datacore today [options]
 
 Description:
-  Creates a snapshot of your Datacore installation including:
-  - Installed modules (with git commit hashes)
-  - Spaces (with git sources)
+  Generates your daily briefing by invoking the /today command.
+  Includes:
+  - Calendar events
+  - Priority tasks
+  - Nightshift results (completed AI tasks)
+  - Journal entry
+
+Options:
+  --format json    Output as JSON
+
+Examples:
+  datacore today`);
+  } else {
+    console.log(`datacore tomorrow - End-of-day wrap-up
+
+Usage:
+  datacore tomorrow [options]
+
+Description:
+  Wraps up your day by invoking the /tomorrow command.
+  Includes:
+  - Session summary
+  - Queuing AI tasks for overnight
+  - Learning extraction
+  - Journal update
+
+Options:
+  --format json    Output as JSON
+
+Examples:
+  datacore tomorrow`);
+  }
+}
+function showActionHelp(resource, action) {
+  if (!RESOURCES.includes(resource)) {
+    console.log(`Unknown resource: ${resource}`);
+    return;
+  }
+  const actions = ACTIONS[resource];
+  if (!actions.includes(action)) {
+    console.log(`Unknown action: ${action} for ${resource}
+
+Available actions: ${actions.join(", ")}`);
+    return;
+  }
+  const help = getDetailedHelp(resource, action);
+  console.log(help);
+}
+function getResourceDescription(resource) {
+  const descriptions = {
+    space: "Create and list spaces",
+    module: "Install and manage modules",
+    config: "View and modify settings",
+    nightshift: "Queue and trigger AI tasks",
+    cron: "Manage scheduled tasks",
+    snapshot: "Create and restore installation snapshots"
+  };
+  return descriptions[resource];
+}
+function getActionDescription(resource, action) {
+  const descriptions = {
+    "space create": "Create a new space",
+    "space list": "List all spaces",
+    "module install": "Install a module",
+    "module list": "List installed modules",
+    "module update": "Update all modules",
+    "module remove": "Remove a module",
+    "config show": "Show all settings",
+    "config get": "Get a setting value",
+    "config set": "Set a setting value",
+    "nightshift status": "Show queue and server status",
+    "nightshift trigger": "Execute queued AI tasks",
+    "nightshift queue": "Add task to AI queue",
+    "cron install": "Install scheduled jobs",
+    "cron status": "Show job status",
+    "cron remove": "Remove scheduled jobs",
+    "snapshot create": "Create installation snapshot",
+    "snapshot restore": "Restore from snapshot",
+    "snapshot diff": "Compare with snapshot",
+    "snapshot show": "Show snapshot contents"
+  };
+  return descriptions[`${resource} ${action}`] ?? action;
+}
+function getDetailedHelp(resource, action) {
+  const key = `${resource} ${action}`;
+  const helpTexts = {
+    "space create": `datacore space create - Create a new space
+
+Usage:
+  datacore space create [options]
+
+Description:
+  Interactive wizard to create a new team or personal space.
+  Invokes the create-space agent for semantic decisions.
+
+Options:
+  --name <name>    Space name (lowercase, hyphenated)
+  --type <type>    Space type: team or personal
+  --yes, -y        Use defaults
+
+Examples:
+  datacore space create
+  datacore space create --name fds --type team`,
+    "space list": `datacore space list - List all spaces
+
+Usage:
+  datacore space list [options]
+
+Description:
+  Lists all spaces in your Datacore installation.
+
+Options:
+  --format json    Output as JSON
+
+Examples:
+  datacore space list`,
+    "module install": `datacore module install - Install a module
+
+Usage:
+  datacore module install <name> [options]
+
+Description:
+  Clones a module from the Datacore catalog and registers
+  its agents and commands.
+
+Arguments:
+  <name>           Module name (e.g., nightshift)
+
+Examples:
+  datacore module install nightshift
+  datacore module install crm`,
+    "module list": `datacore module list - List modules
+
+Usage:
+  datacore module list [options]
+
+Description:
+  Shows installed modules and available modules from catalog.
+
+Options:
+  --available      Show only available (not installed)
+  --format json    Output as JSON
+
+Examples:
+  datacore module list
+  datacore module list --available`,
+    "config show": `datacore config show - Show all settings
+
+Usage:
+  datacore config show [options]
+
+Description:
+  Displays merged configuration from base and local settings.
+
+Options:
+  --format json    Output as JSON
+
+Examples:
+  datacore config show`,
+    "config get": `datacore config get - Get a setting value
+
+Usage:
+  datacore config get <key>
+
+Arguments:
+  <key>            Setting key (e.g., sync.pull_on_today)
+
+Examples:
+  datacore config get sync.pull_on_today
+  datacore config get editor.open_command`,
+    "config set": `datacore config set - Set a setting value
+
+Usage:
+  datacore config set <key> <value>
+
+Description:
+  Updates settings.local.yaml with the new value.
+
+Arguments:
+  <key>            Setting key
+  <value>          New value
+
+Examples:
+  datacore config set sync.pull_on_today false
+  datacore config set editor.open_command code`,
+    "nightshift status": `datacore nightshift status - Queue and server status
+
+Usage:
+  datacore nightshift status [options]
+
+Description:
+  Shows nightshift queue summary and server connection status.
+
+Options:
+  --format json    Output as JSON
+
+Examples:
+  datacore nightshift status`,
+    "nightshift trigger": `datacore nightshift trigger - Execute queued AI tasks
+
+Usage:
+  datacore nightshift trigger
+
+Description:
+  Manually triggers execution of queued AI tasks.
+  Normally called by cron job at night.
+
+Examples:
+  datacore nightshift trigger`,
+    "nightshift queue": `datacore nightshift queue - Add task to AI queue
+
+Usage:
+  datacore nightshift queue "<task description>"
+
+Description:
+  Quick way to add an AI task without editing org files.
+  Adds entry to inbox.org with :AI: tag.
+
+Arguments:
+  <task>           Task description
+
+Examples:
+  datacore nightshift queue "Research competitor analysis"
+  datacore nightshift queue "Generate weekly metrics report"`,
+    "cron install": `datacore cron install - Install scheduled jobs
+
+Usage:
+  datacore cron install [options]
+
+Description:
+  Sets up platform-specific scheduled tasks:
+  - macOS: launchd plist
+  - Linux: crontab entry
+
+Options:
+  --schedule <cron>  Custom schedule (default: nightly)
+
+Examples:
+  datacore cron install
+  datacore cron install --schedule "0 2 * * *"`,
+    "snapshot create": `datacore snapshot create - Create installation snapshot
+
+Usage:
+  datacore snapshot create [path] [options]
+
+Description:
+  Creates a snapshot of your Datacore installation including:
+  - Installed modules (with git commit hashes)
+  - Spaces (with git sources)
   - Dependency versions
   - Optionally: base settings
 
@@ -7961,6 +8396,13 @@ function getInstallCommand(pkg, platform2) {
       windows: "winget install Python.Python.3.11",
       unknown: null
     },
+    gh: {
+      macos: "brew install gh",
+      linux: "sudo apt-get install gh",
+      wsl: "sudo apt-get install gh",
+      windows: "winget install GitHub.cli",
+      unknown: null
+    },
     claude: {
       macos: "npm install -g @anthropic-ai/claude-code",
       linux: "npm install -g @anthropic-ai/claude-code",
@@ -8096,11 +8538,28 @@ function checkPython(platform2) {
     installCommand: !installed || !meetsMin ? getInstallCommand("python", platform2) ?? undefined : undefined
   };
 }
-function checkClaude(platform2) {
-  const installed = commandExists("claude");
-  return {
-    name: "claude",
-    required: false,
+function checkGh(platform2) {
+  const installed = commandExists("gh");
+  let authenticated = false;
+  if (installed) {
+    try {
+      execSync2("gh auth status", { stdio: "pipe" });
+      authenticated = true;
+    } catch {}
+  }
+  return {
+    name: "gh",
+    required: false,
+    installed: installed && authenticated,
+    version: installed ? getVersion("gh") : undefined,
+    installCommand: installed ? authenticated ? undefined : "gh auth login" : getInstallCommand("gh", platform2) ?? undefined
+  };
+}
+function checkClaude(platform2) {
+  const installed = commandExists("claude");
+  return {
+    name: "claude",
+    required: false,
     installed,
     version: installed ? getVersion("claude", "--version") : undefined,
     installCommand: installed ? undefined : getInstallCommand("claude", platform2) ?? undefined
@@ -8113,6 +8572,7 @@ function checkDependencies() {
     checkGitLfs(platform2),
     checkNode(platform2),
     checkPython(platform2),
+    checkGh(platform2),
     checkClaude(platform2)
   ];
 }
@@ -8305,351 +8765,21 @@ function getAllConfig() {
         }
         if (check !== undefined) {
           sources[pathStr] = "base";
-          continue;
-        }
-        sources[pathStr] = "default";
-      }
-    }
-  }
-  traceSources(merged);
-  return { merged, sources };
-}
-
-// src/lib/space.ts
-import { existsSync as existsSync3, readdirSync, statSync, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3, basename } from "path";
-var DATA_DIR2 = join3(process.env.HOME || "~", "Data");
-function listSpaces() {
-  if (!existsSync3(DATA_DIR2)) {
-    return [];
-  }
-  const entries = readdirSync(DATA_DIR2, { withFileTypes: true });
-  const spaces = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory())
-      continue;
-    const match = entry.name.match(/^(\d+)-(.+)$/);
-    if (!match)
-      continue;
-    const [, numStr, name] = match;
-    const number = parseInt(numStr, 10);
-    const path = join3(DATA_DIR2, entry.name);
-    spaces.push({
-      name: entry.name,
-      number,
-      path,
-      type: number === 0 ? "personal" : "team",
-      hasGit: existsSync3(join3(path, ".git")),
-      hasClaude: existsSync3(join3(path, "CLAUDE.md")) || existsSync3(join3(path, "CLAUDE.base.md"))
-    });
-  }
-  spaces.sort((a, b) => a.number - b.number);
-  return spaces;
-}
-function getNextSpaceNumber() {
-  const spaces = listSpaces();
-  if (spaces.length === 0)
-    return 0;
-  const maxNumber = Math.max(...spaces.map((s) => s.number));
-  return maxNumber + 1;
-}
-function createSpace(name, type = "team") {
-  const number = type === "personal" ? 0 : getNextSpaceNumber();
-  const normalizedName = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-  const folderName = `${number}-${normalizedName}`;
-  const spacePath = join3(DATA_DIR2, folderName);
-  if (existsSync3(spacePath)) {
-    throw new Error(`Space already exists: ${folderName}`);
-  }
-  mkdirSync2(spacePath, { recursive: true });
-  const dirs = type === "personal" ? [
-    ".datacore",
-    ".datacore/commands",
-    ".datacore/agents",
-    ".datacore/learning",
-    ".datacore/state",
-    ".datacore/env",
-    "org",
-    "0-inbox",
-    "notes",
-    "notes/journals",
-    "notes/pages",
-    "notes/zettel",
-    "journal",
-    "3-knowledge",
-    "3-knowledge/pages",
-    "3-knowledge/zettel",
-    "3-knowledge/literature",
-    "3-knowledge/reference",
-    "4-archive",
-    "content"
-  ] : [
-    ".datacore",
-    ".datacore/commands",
-    ".datacore/agents",
-    ".datacore/learning",
-    ".datacore/state",
-    ".datacore/env",
-    "org",
-    "0-inbox",
-    "journal",
-    "1-tracks",
-    "1-tracks/ops",
-    "1-tracks/product",
-    "1-tracks/dev",
-    "1-tracks/research",
-    "1-tracks/comms",
-    "2-projects",
-    "3-knowledge",
-    "3-knowledge/pages",
-    "3-knowledge/zettel",
-    "3-knowledge/literature",
-    "3-knowledge/reference",
-    "4-archive"
-  ];
-  for (const dir of dirs) {
-    mkdirSync2(join3(spacePath, dir), { recursive: true });
-  }
-  if (type === "personal") {
-    writeFileSync2(join3(spacePath, "org", "inbox.org"), `#+TITLE: Inbox
-#+FILETAGS: :inbox:
-
-Capture everything here. Process daily to zero.
-
-* TODO Do more. With less.
-* Inbox
-`);
-    writeFileSync2(join3(spacePath, "org", "next_actions.org"), `#+TITLE: Next Actions
-#+TODO: TODO NEXT WAITING | DONE CANCELED
-#+FILETAGS: :tasks:
-
-Tasks organized by focus area. Tag with :AI: to delegate to agents.
-
-* TIER 1: STRATEGIC FOUNDATION
-** /Projects
-** /Work
-* TIER 2: SUPPORTING WORK
-** Admin
-** Maintenance
-* PERSONAL: LIFE & DEVELOPMENT
-** /Personal Development
-** /Health & Longevity
-** Home & Family
-** Financial Management
-* RESEARCH & LEARNING
-** Technology
-** Skills
-`);
-    writeFileSync2(join3(spacePath, "org", "nightshift.org"), `#+TITLE: Nightshift Queue
-#+TODO: QUEUED EXECUTING | DONE FAILED
-#+FILETAGS: :nightshift:
-
-AI tasks queued for overnight execution. Managed by /tomorrow command.
-
-* Queue
-`);
-    writeFileSync2(join3(spacePath, "org", "habits.org"), `#+TITLE: Habits
-#+FILETAGS: :habits:
-
-Recurring behaviors and routines. Track with org-habit.
-
-* Daily
-* Weekly
-* Monthly
-`);
-    writeFileSync2(join3(spacePath, "org", "someday.org"), `#+TITLE: Someday/Maybe
-#+FILETAGS: :someday:
-
-Ideas and projects for the future. Review monthly.
-
-* Someday
-* Maybe
-`);
-    writeFileSync2(join3(spacePath, "org", "archive.org"), `#+TITLE: Archive
-#+FILETAGS: :archive:
-
-Completed and canceled tasks. Searchable history.
-
-* Archived Tasks
-`);
-  } else {
-    writeFileSync2(join3(spacePath, "org", "inbox.org"), `#+TITLE: Inbox
-#+FILETAGS: :inbox:
-
-* Capture items here
-`);
-    writeFileSync2(join3(spacePath, "org", "next_actions.org"), `#+TITLE: Next Actions
-#+FILETAGS: :tasks:
-
-* Tasks
-** TODO items go here
-`);
-  }
-  if (type === "personal") {
-    writeFileSync2(join3(spacePath, "_index.md"), `# Personal Space
-
-Your personal knowledge base and GTD system.
-
-## GTD Workflow
-
-1. **Capture** → \`org/inbox.org\` - dump everything here
-2. **Clarify** → Is it actionable? What's the next action?
-3. **Organize** → Move to \`next_actions.org\` by focus area
-4. **Reflect** → Weekly review, monthly strategic
-5. **Engage** → Do the work, delegate with :AI: tags
-
-## Org Files (GTD)
-
-| File | Purpose |
-|------|---------|
-| [inbox.org](org/inbox.org) | Single capture point - process to zero daily |
-| [next_actions.org](org/next_actions.org) | Active tasks by focus area |
-| [nightshift.org](org/nightshift.org) | AI task queue (overnight processing) |
-| [habits.org](org/habits.org) | Recurring behaviors |
-| [someday.org](org/someday.org) | Future possibilities |
-| [archive.org](org/archive.org) | Completed/canceled tasks |
-
-## Knowledge
-
-| Folder | Purpose |
-|--------|---------|
-| [notes/](notes/) | Personal knowledge base (Obsidian) |
-| [notes/journals/](notes/journals/) | Daily personal journals |
-| [3-knowledge/](3-knowledge/) | Structured knowledge (zettelkasten) |
-
-## Other
-
-- [journal/](journal/) - AI session journals (auto-generated)
-- [content/](content/) - Generated content (drafts, emails)
-- [0-inbox/](0-inbox/) - File inbox (process files here)
-- [4-archive/](4-archive/) - Historical content
-`);
-  } else {
-    writeFileSync2(join3(spacePath, "_index.md"), `# ${name}
-
-Team space.
-
-## Structure
-
-- \`org/\` - Task coordination
-- \`1-tracks/\` - Department work
-- \`2-projects/\` - Code repositories
-- \`3-knowledge/\` - Shared knowledge
-- \`4-archive/\` - Historical content
-
-## Quick Links
-
-- [Inbox](org/inbox.org)
-- [Tasks](org/next_actions.org)
-- [Journal](journal/)
-- [Knowledge](3-knowledge/)
-`);
-  }
-  if (type === "personal") {
-    writeFileSync2(join3(spacePath, "CLAUDE.base.md"), `# Personal Space
-
-Personal GTD system and knowledge base (per DIP-0009).
-
-## GTD Files
-
-| File | Purpose | Process |
-|------|---------|---------|
-| \`org/inbox.org\` | Single capture point | Process to zero daily |
-| \`org/next_actions.org\` | Active tasks by focus area | Work from here |
-| \`org/nightshift.org\` | AI task queue | Auto-managed by /tomorrow |
-| \`org/habits.org\` | Recurring behaviors | Track daily |
-| \`org/someday.org\` | Future possibilities | Review monthly |
-| \`org/archive.org\` | Completed tasks | Searchable history |
-
-## Task States
-
-| State | Meaning |
-|-------|---------|
-| \`TODO\` | Standard next action |
-| \`NEXT\` | High priority, work today |
-| \`WAITING\` | Blocked on external |
-| \`DONE\` | Completed (terminal) |
-| \`CANCELED\` | Will not do (terminal) |
-
-## AI Delegation
-
-Tag tasks with \`:AI:\` to delegate to agents:
-
-| Tag | Agent | Autonomous |
-|-----|-------|------------|
-| \`:AI:content:\` | gtd-content-writer | Yes |
-| \`:AI:research:\` | gtd-research-processor | Yes |
-| \`:AI:data:\` | gtd-data-analyzer | Yes |
-| \`:AI:pm:\` | gtd-project-manager | Yes |
-
-## Knowledge Structure
-
-| Location | Purpose |
-|----------|---------|
-| \`notes/\` | Personal knowledge base (Obsidian) |
-| \`notes/journals/\` | Daily personal reflections |
-| \`3-knowledge/zettel/\` | Atomic concept notes |
-| \`3-knowledge/literature/\` | Source summaries |
-
-## Daily Workflow
-
-1. **Morning** - Run \`/today\` for briefing
-2. **Capture** - Everything to inbox.org
-3. **Process** - Clear inbox, route tasks
-4. **Work** - Focus on NEXT items
-5. **Evening** - Run \`/tomorrow\` for wrap-up
-
-## See Also
-
-Parent: ~/Data/CLAUDE.md
-`);
-  } else {
-    writeFileSync2(join3(spacePath, "CLAUDE.base.md"), `# ${name} Space
-
-Team space for ${name}.
-
-## Structure
-
-See parent CLAUDE.md for full documentation.
-`);
+          continue;
+        }
+        sources[pathStr] = "default";
+      }
+    }
   }
-  writeFileSync2(join3(spacePath, ".datacore", "config.yaml"), `# Space configuration
-name: ${normalizedName}
-type: ${type}
-`);
-  writeFileSync2(join3(spacePath, ".datacore", "learning", "patterns.md"), `# Patterns
-
-Successful approaches to remember.
-`);
-  writeFileSync2(join3(spacePath, ".datacore", "learning", "corrections.md"), `# Corrections
-
-Human feedback log.
-`);
-  writeFileSync2(join3(spacePath, ".datacore", "learning", "preferences.md"), `# Preferences
-
-Style and preference notes.
-`);
-  writeFileSync2(join3(spacePath, ".gitignore"), type === "personal" ? `.datacore/state/
-.datacore/env/
-CLAUDE.md
-CLAUDE.local.md
-` : `.datacore/state/
-.datacore/env/
-CLAUDE.md
-CLAUDE.local.md
-2-projects/
-`);
-  return {
-    name: folderName,
-    number,
-    path: spacePath,
-    type,
-    hasGit: false,
-    hasClaude: true
-  };
+  traceSources(merged);
+  return { merged, sources };
 }
 
+// src/index.ts
+init_space();
+
 // src/lib/sync.ts
+init_space();
 import { execSync as execSync3 } from "child_process";
 import { existsSync as existsSync4 } from "fs";
 import { join as join4, basename as basename2 } from "path";
@@ -8784,46 +8914,89 @@ function getGitRepos() {
 }
 
 // src/lib/init.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4, symlinkSync } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, writeFileSync as writeFileSync5, symlinkSync, copyFileSync, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync2, cpSync } from "fs";
+import { join as join10, basename as basename5 } from "path";
+import { execFileSync as execFileSync2 } from "child_process";
 import { createInterface } from "readline";
 
 // src/lib/module.ts
 import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync2, rmSync } from "fs";
 import { join as join5, basename as basename3 } from "path";
-import { execSync as execSync4 } from "child_process";
-var DATA_DIR4 = join5(process.env.HOME || "~", "Data");
+import { execFileSync } from "child_process";
+var DATA_DIR4 = join5(process.env.HOME || "", "Data");
 var MODULES_DIR = join5(DATA_DIR4, ".datacore", "modules");
 var AVAILABLE_MODULES = [
   {
     name: "nightshift",
-    description: "Overnight AI task execution",
-    repo: "https://github.com/datacore-one/module-nightshift",
-    features: ["Queues :AI: tasks for overnight processing", "Morning briefing with results", "Remote server support"]
+    description: "Autonomous AI task execution (local mode)",
+    repo: "https://github.com/datacore-one/datacore-nightshift",
+    features: ["Queues :AI: tasks for background processing", "Morning briefing with results", "Multi-persona evaluation"],
+    core: true
+  },
+  {
+    name: "health",
+    description: "Health and wellness tracking - sleep, exercise, habits",
+    repo: "https://github.com/datacore-one/datacore-health",
+    features: ["Daily check-ins", "Habit tracking and streaks", "Health reports and correlations"],
+    core: false
   },
   {
     name: "crm",
-    description: "Contact relationship management",
-    repo: "https://github.com/datacore-one/module-crm",
-    features: ["Contact profiles", "Interaction history", "Relationship tracking"]
+    description: "Network intelligence and contact management",
+    repo: "https://github.com/datacore-one/datacore-crm",
+    features: ["Contact profiles and interaction history", "Relationship tracking", "Industry landscape mapping"],
+    core: false
   },
   {
     name: "meetings",
-    description: "Meeting preparation and follow-up",
-    repo: "https://github.com/datacore-one/module-meetings",
-    features: ["Pre-meeting briefs", "Transcript processing", "Action item extraction"]
+    description: "Meeting lifecycle automation",
+    repo: "https://github.com/datacore-one/datacore-meetings",
+    features: ["Pre-meeting briefs", "Transcript processing", "Action item extraction"],
+    core: false
   },
   {
-    name: "health",
-    description: "Personal health and wellness tracking",
-    repo: "https://github.com/datacore-one/module-health",
-    features: ["Health metrics", "Habit tracking", "Wellness insights"]
+    name: "mail",
+    description: "Email integration and processing",
+    repo: "https://github.com/datacore-one/datacore-mail",
+    features: ["Gmail adapter", "AI classification and routing", "Automated processing"],
+    core: false
+  },
+  {
+    name: "news",
+    description: "Automated news aggregation with AI-scored relevance",
+    repo: "https://github.com/datacore-one/datacore-news",
+    features: ["Multi-source aggregation", "AI relevance scoring", "Tiered processing"],
+    core: false
+  },
+  {
+    name: "slides",
+    description: "Presentation generation via Gamma.app",
+    repo: "https://github.com/datacore-one/datacore-slides",
+    features: ["Presentations via Gamma.app", "AI-powered backgrounds", "Template support"],
+    core: false
+  },
+  {
+    name: "trading",
+    description: "Position management and trading workflows",
+    repo: "https://github.com/datacore-one/datacore-trading",
+    features: ["Position tracking", "Performance analytics", "Risk management"],
+    core: false
+  },
+  {
+    name: "telegram",
+    description: "Mobile access to Claude Code via Telegram",
+    repo: "https://github.com/datacore-one/datacore-telegram",
+    features: ["Message relay", "Command execution", "File sharing"],
+    core: false
+  },
+  {
+    name: "campaigns",
+    description: "Landing pages, deployment, and A/B testing",
+    repo: "https://github.com/datacore-one/datacore-campaigns",
+    features: ["Landing page generation", "PostHog analytics", "A/B testing"],
+    core: false
   }
 ];
-function getAvailableModules() {
-  const installed = listModules().map((m) => m.name);
-  return AVAILABLE_MODULES.filter((m) => !installed.includes(m.name));
-}
 function listModules() {
   if (!existsSync5(MODULES_DIR)) {
     return [];
@@ -8869,108 +9042,362 @@ function getModuleInfo(modulePath) {
       }
     }
   }
-  const commandsDir = join5(modulePath, "commands");
-  const commands = [];
-  if (existsSync5(commandsDir)) {
-    const cmdFiles = readdirSync2(commandsDir);
-    for (const file of cmdFiles) {
-      if (file.endsWith(".md")) {
-        commands.push(file.replace(".md", ""));
-      }
+  const commandsDir = join5(modulePath, "commands");
+  const commands = [];
+  if (existsSync5(commandsDir)) {
+    const cmdFiles = readdirSync2(commandsDir);
+    for (const file of cmdFiles) {
+      if (file.endsWith(".md")) {
+        commands.push(file.replace(".md", ""));
+      }
+    }
+  }
+  return {
+    name,
+    path: modulePath,
+    version,
+    description,
+    agents,
+    commands
+  };
+}
+function installModule(source) {
+  if (!existsSync5(MODULES_DIR)) {
+    const { mkdirSync: mkdirSync3 } = __require("fs");
+    mkdirSync3(MODULES_DIR, { recursive: true });
+  }
+  let name;
+  let isGit = false;
+  if (source.includes("github.com") || source.startsWith("git@") || source.endsWith(".git")) {
+    isGit = true;
+    const match = source.match(/([^/]+?)(?:\.git)?$/);
+    name = match?.[1] ?? source.split("/").pop() ?? "unknown";
+    name = name.replace(/^module-/, "").replace(/^datacore-/, "");
+  } else if (source.startsWith("@")) {
+    name = source.split("/").pop()?.replace(/^datacore-/, "") ?? "unknown";
+  } else {
+    name = source.replace(/^datacore-/, "").replace(/^module-/, "");
+  }
+  const modulePath = join5(MODULES_DIR, name);
+  if (existsSync5(modulePath)) {
+    throw new Error(`Module already installed: ${name}`);
+  }
+  if (isGit) {
+    try {
+      execFileSync("git", ["clone", source, modulePath], { stdio: "pipe", timeout: 300000 });
+    } catch {
+      const sshUrl = source.replace("https://github.com/", "git@github.com:");
+      try {
+        execFileSync("git", ["clone", sshUrl, modulePath], { stdio: "pipe", timeout: 300000 });
+      } catch {
+        throw new Error(`Could not clone module: ${source} (tried HTTPS and SSH)`);
+      }
+    }
+  } else {
+    const catalogEntry = AVAILABLE_MODULES.find((m) => m.name === name);
+    if (catalogEntry) {
+      return installModule(catalogEntry.repo);
+    }
+    const urls = [
+      `https://github.com/datacore-one/datacore-${name}`,
+      `https://github.com/datacore-one/module-${name}`
+    ];
+    let installed = false;
+    for (const url of urls) {
+      try {
+        execFileSync("git", ["clone", url, modulePath], { stdio: "pipe", timeout: 300000 });
+        installed = true;
+        break;
+      } catch {
+        continue;
+      }
+    }
+    if (!installed) {
+      throw new Error(`Could not install module "${source}". Try providing a full git URL.`);
+    }
+  }
+  const info2 = getModuleInfo(modulePath);
+  if (!info2) {
+    rmSync(modulePath, { recursive: true, force: true });
+    throw new Error("Invalid module: missing module.yaml");
+  }
+  return info2;
+}
+function updateModules(name) {
+  const modules = listModules();
+  const results = [];
+  const toUpdate = name ? modules.filter((m) => m.name === name) : modules;
+  for (const mod of toUpdate) {
+    try {
+      const gitDir = join5(mod.path, ".git");
+      if (existsSync5(gitDir)) {
+        execFileSync("git", ["pull"], { cwd: mod.path, stdio: "pipe", timeout: 60000 });
+        results.push({ name: mod.name, updated: true });
+      } else {
+        results.push({ name: mod.name, updated: false, error: "Not a git repository" });
+      }
+    } catch (err) {
+      results.push({ name: mod.name, updated: false, error: err.message });
+    }
+  }
+  return results;
+}
+function removeModule(name) {
+  const modulePath = join5(MODULES_DIR, name);
+  if (!existsSync5(modulePath)) {
+    return false;
+  }
+  rmSync(modulePath, { recursive: true, force: true });
+  return true;
+}
+
+// src/lib/init.ts
+init_space();
+init_agent();
+
+// src/lib/snapshot.ts
+init_space();
+var import_yaml2 = __toESM(require_dist(), 1);
+import { existsSync as existsSync7, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
+import { execSync as execSync4 } from "child_process";
+import { join as join7 } from "path";
+var DATA_DIR6 = join7(process.env.HOME || "~", "Data");
+var LOCK_FILE = join7(DATA_DIR6, "datacore.lock.yaml");
+var CLI_VERSION = "1.0.6";
+function getGitInfo(path) {
+  if (!existsSync7(join7(path, ".git"))) {
+    return {};
+  }
+  try {
+    const remote = execSync4("git remote get-url origin 2>/dev/null || true", {
+      cwd: path,
+      encoding: "utf-8"
+    }).trim() || undefined;
+    const commit = execSync4("git rev-parse HEAD 2>/dev/null || true", {
+      cwd: path,
+      encoding: "utf-8"
+    }).trim() || undefined;
+    const branch = execSync4("git branch --show-current 2>/dev/null || true", {
+      cwd: path,
+      encoding: "utf-8"
+    }).trim() || undefined;
+    return { remote, commit, branch };
+  } catch {
+    return {};
+  }
+}
+function createSnapshot(options = {}) {
+  const { includeSettings = false } = options;
+  const modules = [];
+  for (const mod of listModules()) {
+    const gitInfo = getGitInfo(mod.path);
+    modules.push({
+      name: mod.name,
+      source: gitInfo.remote || "local",
+      version: mod.version,
+      commit: gitInfo.commit,
+      branch: gitInfo.branch
+    });
+  }
+  const spaces = [];
+  for (const space of listSpaces()) {
+    const gitInfo = getGitInfo(space.path);
+    spaces.push({
+      name: space.name,
+      number: space.number,
+      type: space.type,
+      source: gitInfo.remote,
+      commit: gitInfo.commit
+    });
+  }
+  const deps = checkDependencies();
+  const dependencies = deps.filter((d) => d.installed && d.version).map((d) => ({
+    name: d.name,
+    version: d.version,
+    required: d.required
+  }));
+  const snapshot = {
+    version: "1.0",
+    created: new Date().toISOString(),
+    cliVersion: CLI_VERSION,
+    platform: `${process.platform}-${process.arch}`,
+    modules,
+    spaces,
+    dependencies
+  };
+  if (includeSettings) {
+    const settingsPath = join7(DATA_DIR6, ".datacore", "settings.yaml");
+    if (existsSync7(settingsPath)) {
+      try {
+        const content = readFileSync3(settingsPath, "utf-8");
+        snapshot.settings = import_yaml2.parse(content);
+      } catch {}
+    }
+  }
+  return snapshot;
+}
+function saveSnapshot(snapshot, path) {
+  const lockPath = path || LOCK_FILE;
+  const content = import_yaml2.stringify(snapshot, {
+    lineWidth: 0
+  });
+  writeFileSync3(lockPath, content);
+  return lockPath;
+}
+function loadSnapshot(path) {
+  const lockPath = path || LOCK_FILE;
+  if (!existsSync7(lockPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync3(lockPath, "utf-8");
+    return import_yaml2.parse(content);
+  } catch {
+    return null;
+  }
+}
+function diffSnapshot(snapshot) {
+  const current = createSnapshot();
+  const diff = {
+    modules: { added: [], removed: [], changed: [] },
+    spaces: { added: [], removed: [] },
+    dependencies: { changed: [] }
+  };
+  const currentModules = new Map(current.modules.map((m) => [m.name, m]));
+  const snapshotModules = new Map(snapshot.modules.map((m) => [m.name, m]));
+  for (const [name, mod] of currentModules) {
+    if (!snapshotModules.has(name)) {
+      diff.modules.added.push(name);
+    } else {
+      const expected = snapshotModules.get(name);
+      if (expected.commit && mod.commit && expected.commit !== mod.commit) {
+        diff.modules.changed.push({
+          name,
+          from: expected.commit.slice(0, 7),
+          to: mod.commit.slice(0, 7)
+        });
+      }
+    }
+  }
+  for (const name of snapshotModules.keys()) {
+    if (!currentModules.has(name)) {
+      diff.modules.removed.push(name);
     }
   }
-  return {
-    name,
-    path: modulePath,
-    version,
-    description,
-    agents,
-    commands
-  };
-}
-function installModule(source) {
-  if (!existsSync5(MODULES_DIR)) {
-    const { mkdirSync: mkdirSync3 } = __require("fs");
-    mkdirSync3(MODULES_DIR, { recursive: true });
-  }
-  let name;
-  let isGit = false;
-  if (source.includes("github.com") || source.startsWith("git@") || source.endsWith(".git")) {
-    isGit = true;
-    const match = source.match(/([^/]+?)(?:\.git)?$/);
-    name = match?.[1] ?? source.split("/").pop() ?? "unknown";
-    name = name.replace(/^module-/, "");
-  } else if (source.startsWith("@")) {
-    name = source.split("/").pop()?.replace(/^datacore-/, "") ?? "unknown";
-  } else {
-    name = source.replace(/^datacore-/, "").replace(/^module-/, "");
-  }
-  const modulePath = join5(MODULES_DIR, name);
-  if (existsSync5(modulePath)) {
-    throw new Error(`Module already installed: ${name}`);
+  const currentSpaces = new Set(current.spaces.map((s) => s.name));
+  const snapshotSpaces = new Set(snapshot.spaces.map((s) => s.name));
+  for (const name of currentSpaces) {
+    if (!snapshotSpaces.has(name)) {
+      diff.spaces.added.push(name);
+    }
   }
-  if (isGit) {
-    execSync4(`git clone ${source} "${modulePath}"`, { stdio: "pipe" });
-  } else {
-    const gitUrl = `https://github.com/datacore/module-${name}.git`;
-    try {
-      execSync4(`git clone ${gitUrl} "${modulePath}"`, { stdio: "pipe" });
-    } catch {
-      throw new Error(`Could not install module: ${source}`);
+  for (const name of snapshotSpaces) {
+    if (!currentSpaces.has(name)) {
+      diff.spaces.removed.push(name);
     }
   }
-  const info2 = getModuleInfo(modulePath);
-  if (!info2) {
-    rmSync(modulePath, { recursive: true, force: true });
-    throw new Error("Invalid module: missing module.yaml");
+  const currentDeps = new Map(current.dependencies.map((d) => [d.name, d.version]));
+  for (const dep of snapshot.dependencies) {
+    const actualVersion = currentDeps.get(dep.name);
+    if (actualVersion && actualVersion !== dep.version) {
+      diff.dependencies.changed.push({
+        name: dep.name,
+        expected: dep.version,
+        actual: actualVersion
+      });
+    }
   }
-  return info2;
+  return diff;
 }
-function updateModules(name) {
-  const modules = listModules();
-  const results = [];
-  const toUpdate = name ? modules.filter((m) => m.name === name) : modules;
-  for (const mod of toUpdate) {
-    try {
-      const gitDir = join5(mod.path, ".git");
-      if (existsSync5(gitDir)) {
-        execSync4("git pull", { cwd: mod.path, stdio: "pipe" });
-        results.push({ name: mod.name, updated: true });
-      } else {
-        results.push({ name: mod.name, updated: false, error: "Not a git repository" });
+function restoreFromSnapshot(snapshot, options = {}) {
+  const { modules = true, spaces = true, dryRun = false } = options;
+  const result = {
+    modulesInstalled: [],
+    modulesFailed: [],
+    spacesCreated: [],
+    warnings: []
+  };
+  if (modules) {
+    const currentModules = new Set(listModules().map((m) => m.name));
+    for (const mod of snapshot.modules) {
+      if (currentModules.has(mod.name)) {
+        continue;
+      }
+      if (mod.source === "local") {
+        result.warnings.push(`Module ${mod.name} was local, cannot restore`);
+        continue;
+      }
+      if (dryRun) {
+        result.modulesInstalled.push(mod.name);
+        continue;
+      }
+      try {
+        const modulesDir = join7(DATA_DIR6, ".datacore", "modules");
+        if (!existsSync7(modulesDir)) {
+          mkdirSync3(modulesDir, { recursive: true });
+        }
+        const modulePath = join7(modulesDir, mod.name);
+        execSync4(`git clone ${mod.source} "${modulePath}"`, { stdio: "pipe" });
+        if (mod.commit) {
+          execSync4(`git checkout ${mod.commit}`, { cwd: modulePath, stdio: "pipe" });
+        } else if (mod.branch) {
+          execSync4(`git checkout ${mod.branch}`, { cwd: modulePath, stdio: "pipe" });
+        }
+        result.modulesInstalled.push(mod.name);
+      } catch (err) {
+        result.modulesFailed.push({
+          name: mod.name,
+          error: err.message
+        });
       }
-    } catch (err) {
-      results.push({ name: mod.name, updated: false, error: err.message });
     }
   }
-  return results;
-}
-function removeModule(name) {
-  const modulePath = join5(MODULES_DIR, name);
-  if (!existsSync5(modulePath)) {
-    return false;
+  if (spaces) {
+    const currentSpaces = new Set(listSpaces().map((s) => s.name));
+    for (const space of snapshot.spaces) {
+      if (currentSpaces.has(space.name)) {
+        continue;
+      }
+      if (dryRun) {
+        result.spacesCreated.push(space.name);
+        continue;
+      }
+      if (space.source) {
+        try {
+          const spacePath = join7(DATA_DIR6, space.name);
+          execSync4(`git clone ${space.source} "${spacePath}"`, { stdio: "pipe" });
+          if (space.commit) {
+            execSync4(`git checkout ${space.commit}`, { cwd: spacePath, stdio: "pipe" });
+          }
+          result.spacesCreated.push(space.name);
+        } catch (err) {
+          result.warnings.push(`Could not clone space ${space.name}: ${err.message}`);
+        }
+      } else {
+        result.warnings.push(`Space ${space.name} has no git source, skipping`);
+      }
+    }
   }
-  rmSync(modulePath, { recursive: true, force: true });
-  return true;
+  return result;
 }
 
 // src/state.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join6 } from "path";
-var STATE_DIR = join6(process.env.HOME || "~", "Data", ".datacore", "state");
-var STATE_FILE = join6(STATE_DIR, "operations.json");
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join8 } from "path";
+var STATE_DIR = join8(process.env.HOME || "~", "Data", ".datacore", "state");
+var STATE_FILE = join8(STATE_DIR, "operations.json");
 function ensureStateDir() {
-  if (!existsSync6(STATE_DIR)) {
-    mkdirSync3(STATE_DIR, { recursive: true });
+  if (!existsSync8(STATE_DIR)) {
+    mkdirSync4(STATE_DIR, { recursive: true });
   }
 }
 function loadState() {
   ensureStateDir();
-  if (!existsSync6(STATE_FILE)) {
+  if (!existsSync8(STATE_FILE)) {
     return { operations: [] };
   }
   try {
-    const content = readFileSync3(STATE_FILE, "utf-8");
+    const content = readFileSync4(STATE_FILE, "utf-8");
     return JSON.parse(content);
   } catch {
     return { operations: [] };
@@ -8978,7 +9405,7 @@ function loadState() {
 }
 function saveState(state) {
   ensureStateDir();
-  writeFileSync3(STATE_FILE, JSON.stringify(state, null, 2));
+  writeFileSync4(STATE_FILE, JSON.stringify(state, null, 2));
 }
 function generateId() {
   return `op_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
@@ -8995,7 +9422,8 @@ class Operation {
       status: "pending",
       startedAt: new Date().toISOString(),
       steps: [],
-      rollback: []
+      rollback: [],
+      meta: Object.keys(params).length > 0 ? params : undefined
     };
     this.store.operations.push(this.state);
     saveState(this.store);
@@ -9087,16 +9515,12 @@ ${c.reset}${c.dim}                    AI-Powered Second Brain ${c.reset}
 `;
 var INIT_COMPLETE = `
 ${c.green}${c.bright}
-    ╔═══════════════════════════════════════════════════════════════╗
-    ║                                                               ║
-    ║   ${c.reset}${c.green}█████╗  ██████╗████████╗██╗██╗   ██╗███████╗${c.bright}                ║
-    ║   ${c.reset}${c.green}██╔══██╗██╔════╝╚══██╔══╝██║██║   ██║██╔════╝${c.bright}                ║
-    ║   ${c.reset}${c.green}███████║██║        ██║   ██║██║   ██║█████╗${c.bright}                  ║
-    ║   ${c.reset}${c.green}██╔══██║██║        ██║   ██║╚██╗ ██╔╝██╔══╝${c.bright}                  ║
-    ║   ${c.reset}${c.green}██║  ██║╚██████╗   ██║   ██║ ╚████╔╝ ███████╗${c.bright}                ║
-    ║   ${c.reset}${c.green}╚═╝  ╚═╝ ╚═════╝   ╚═╝   ╚═╝  ╚═══╝  ╚══════╝${c.bright}                ║
-    ║                                                               ║
-    ╚═══════════════════════════════════════════════════════════════╝
+    ╔══════════════════════════════════════════════════════════╗
+    ║                                                          ║
+    ║   ${c.reset}${c.green}██  D A T A C O R E   S Y S T E M   O N L I N E  ██${c.bright}   ║
+    ║   ${c.reset}${c.dim}       ▸ All systems nominal. Ready to engage. ◂${c.green}${c.bright}      ║
+    ║                                                          ║
+    ╚══════════════════════════════════════════════════════════╝
 ${c.reset}
 `;
 function sleep(ms) {
@@ -9143,9 +9567,76 @@ function section(title) {
   console.log(`${c.dim}${"─".repeat(50)}${c.reset}`);
 }
 
+// src/lib/background.ts
+import { spawn as spawn3 } from "child_process";
+import { openSync, closeSync, mkdirSync as mkdirSync5 } from "fs";
+import { join as join9 } from "path";
+var DATA_DIR7 = join9(process.env.HOME || "", "Data");
+var STATE_DIR2 = join9(DATA_DIR7, ".datacore", "state");
+function spawnBackground(command, args, label) {
+  mkdirSync5(STATE_DIR2, { recursive: true });
+  const timestamp = Date.now();
+  const logFile = join9(STATE_DIR2, `bg-${label}-${timestamp}.log`);
+  let outFd;
+  try {
+    outFd = openSync(logFile, "a");
+    const child = spawn3(command, args, {
+      detached: true,
+      stdio: ["ignore", outFd, outFd],
+      cwd: DATA_DIR7,
+      env: { ...process.env }
+    });
+    child.unref();
+    try {
+      closeSync(outFd);
+    } catch {}
+    return {
+      pid: child.pid ?? -1,
+      logFile,
+      label,
+      startedAt: new Date().toISOString()
+    };
+  } catch {
+    if (outFd !== undefined) {
+      try {
+        closeSync(outFd);
+      } catch {}
+    }
+    return null;
+  }
+}
+
 // src/lib/init.ts
-var DATA_DIR5 = join7(process.env.HOME || "~", "Data");
-var DATACORE_DIR = join7(DATA_DIR5, ".datacore");
+var DATA_DIR8 = join10(process.env.HOME || "", "Data");
+var DATACORE_DIR = join10(DATA_DIR8, ".datacore");
+var UPSTREAM_REPO = "datacore-one/datacore";
+var TOTAL_STEPS = 9;
+var KNOWN_SPACES = [
+  {
+    name: "datafund",
+    displayName: "Datafund",
+    description: "Datafund organization - strategy, operations, investor relations",
+    repo: "https://github.com/datacore-one/datafund-space.git",
+    org: "datacore-one",
+    private: true
+  },
+  {
+    name: "fds",
+    displayName: "Fair Data Society",
+    description: "FDS projects - Fairdrive, Fairdrop, fairOS, identity",
+    repo: "https://github.com/fairDataSociety/fds-space.git",
+    org: "fairDataSociety",
+    private: false
+  },
+  {
+    name: "datacore",
+    displayName: "Datacore",
+    description: "Datacore system development - specs, CLI, modules",
+    repo: "https://github.com/datacore-one/datacore-space.git",
+    org: "datacore-one",
+    private: false
+  }
+];
 var c2 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -9176,13 +9667,245 @@ async function confirm(question, defaultYes = true) {
     return defaultYes;
   return answer.toLowerCase().startsWith("y");
 }
+async function choose(question, options, defaultIndex = 0) {
+  for (let i = 0;i < options.length; i++) {
+    const marker = i === defaultIndex ? `${c2.cyan}>${c2.reset}` : " ";
+    console.log(`  ${marker} ${c2.cyan}${i + 1}${c2.reset}) ${options[i]}`);
+  }
+  console.log();
+  const answer = await prompt(question, String(defaultIndex + 1));
+  const num = parseInt(answer, 10);
+  if (num >= 1 && num <= options.length)
+    return num - 1;
+  return defaultIndex;
+}
+function runArgs(cmd, args, opts) {
+  try {
+    execFileSync2(cmd, args, { stdio: "pipe", cwd: opts?.cwd, timeout: opts?.timeout });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function runArgsWithError(cmd, args, opts) {
+  try {
+    execFileSync2(cmd, args, { stdio: "pipe", cwd: opts?.cwd, timeout: opts?.timeout });
+    return { ok: true };
+  } catch (err) {
+    const stderr = err?.stderr?.toString().trim() || "";
+    return { ok: false, stderr };
+  }
+}
+function initGitInDir(repoUrl, dir, timeout = 300000) {
+  let r = runArgsWithError("git", ["init"], { cwd: dir, timeout: 30000 });
+  if (!r.ok)
+    return r;
+  r = runArgsWithError("git", ["remote", "add", "origin", repoUrl], { cwd: dir, timeout: 5000 });
+  if (!r.ok) {
+    r = runArgsWithError("git", ["remote", "set-url", "origin", repoUrl], { cwd: dir, timeout: 5000 });
+    if (!r.ok)
+      return r;
+  }
+  r = runArgsWithError("git", ["fetch", "origin"], { cwd: dir, timeout });
+  if (!r.ok)
+    return r;
+  const headRef = runArgsOutput("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], { timeout: 5000 });
+  const branch = headRef?.replace("refs/remotes/origin/", "") || "main";
+  r = runArgsWithError("git", ["reset", `origin/${branch}`], { cwd: dir, timeout: 30000 });
+  if (!r.ok)
+    return r;
+  runArgs("git", ["branch", "-M", branch], { cwd: dir });
+  runArgs("git", ["branch", "--set-upstream-to", `origin/${branch}`], { cwd: dir });
+  runArgs("git", ["checkout", "--", "."], { cwd: dir, timeout: 60000 });
+  return { ok: true };
+}
+function runArgsOutput(cmd, args, opts) {
+  try {
+    return execFileSync2(cmd, args, { encoding: "utf-8", stdio: "pipe", timeout: opts?.timeout }).trim();
+  } catch {
+    return "";
+  }
+}
+function commandExists3(cmd) {
+  try {
+    execFileSync2("which", [cmd], { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getVersionString(cmd, flag = "--version") {
+  try {
+    const output2 = execFileSync2(cmd, [flag], { encoding: "utf-8", stdio: "pipe" });
+    return output2.match(/(\d+\.\d+(\.\d+)?)/)?.[0] ?? output2.trim().split(`
+`)[0]?.slice(0, 30);
+  } catch {
+    return;
+  }
+}
+function checkGhAuth() {
+  if (!commandExists3("gh"))
+    return { available: false };
+  try {
+    const output2 = execFileSync2("gh", ["auth", "status"], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 15000 });
+    const combined = output2;
+    const userMatch = combined.match(/Logged in to github\.com.*account (\S+)/i);
+    return { available: true, user: userMatch?.[1] };
+  } catch (err) {
+    const stderr = err?.stderr?.toString() || "";
+    const userMatch = stderr.match(/Logged in to github\.com.*account (\S+)/i);
+    if (userMatch)
+      return { available: true, user: userMatch[1] };
+    return { available: false };
+  }
+}
+function isGitConfigured() {
+  const name = runArgsOutput("git", ["config", "--global", "user.name"]);
+  const email = runArgsOutput("git", ["config", "--global", "user.email"]);
+  return { name: name || undefined, email: email || undefined, configured: !!(name && email) };
+}
+async function ensureDependency(name, checkCmd, platform2, isTTY, versionFlag = "--version") {
+  if (commandExists3(checkCmd)) {
+    const version = getVersionString(checkCmd, versionFlag);
+    return { available: true, version, wasInstalled: false };
+  }
+  const installCmd = getInstallCommand(name, platform2);
+  if (!installCmd) {
+    return { available: false, wasInstalled: false };
+  }
+  const spinner = isTTY ? new Spinner(`Installing ${name}...`) : null;
+  spinner?.start();
+  try {
+    execFileSync2("/bin/bash", ["-c", installCmd], { stdio: "pipe", timeout: 300000 });
+    if (commandExists3(checkCmd)) {
+      const version = getVersionString(checkCmd, versionFlag);
+      spinner?.succeed(`${name} installed${version ? ` (${version})` : ""}`);
+      return { available: true, version, wasInstalled: true };
+    }
+    spinner?.fail(`${name} install completed but command not found in PATH`);
+    if (isTTY)
+      console.log(`    ${c2.dim}Try manually: ${installCmd}${c2.reset}`);
+    return { available: false, wasInstalled: false };
+  } catch {
+    spinner?.fail(`Failed to install ${name}`);
+    if (isTTY)
+      console.log(`    ${c2.dim}Try manually: ${installCmd}${c2.reset}`);
+    return { available: false, wasInstalled: false };
+  }
+}
+async function ensureHomebrew(isTTY) {
+  if (commandExists3("brew"))
+    return true;
+  const brewPaths = ["/opt/homebrew/bin/brew", "/usr/local/bin/brew"];
+  for (const p of brewPaths) {
+    if (existsSync9(p)) {
+      const dir = join10(p, "..");
+      process.env.PATH = `${dir}:${process.env.PATH}`;
+      return true;
+    }
+  }
+  const spinner = isTTY ? new Spinner("Installing Homebrew...") : null;
+  spinner?.start();
+  try {
+    execFileSync2("/bin/bash", ["-c", 'NONINTERACTIVE=1 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"'], {
+      stdio: "pipe",
+      timeout: 600000
+    });
+    for (const p of brewPaths) {
+      if (existsSync9(p)) {
+        const dir = join10(p, "..");
+        process.env.PATH = `${dir}:${process.env.PATH}`;
+        break;
+      }
+    }
+    if (commandExists3("brew")) {
+      spinner?.succeed("Homebrew installed");
+      return true;
+    }
+    spinner?.fail("Homebrew installed but not found in PATH");
+    return false;
+  } catch {
+    spinner?.fail("Failed to install Homebrew");
+    if (isTTY) {
+      console.log(`    ${c2.dim}Install manually: https://brew.sh${c2.reset}`);
+    }
+    return false;
+  }
+}
+function runModulePostInstall(modulePath) {
+  const reqTxt = join10(modulePath, "requirements.txt");
+  if (existsSync9(reqTxt)) {
+    const ok = runArgs("python3", ["-m", "pip", "install", "-r", reqTxt, "--quiet"], { cwd: modulePath, timeout: 120000 });
+    return { ran: true, success: ok, type: "pip" };
+  }
+  const pkgJson = join10(modulePath, "package.json");
+  if (existsSync9(pkgJson)) {
+    try {
+      const pkg = JSON.parse(readFileSync5(pkgJson, "utf-8"));
+      if (pkg.dependencies || pkg.devDependencies) {
+        const ok = runArgs("npm", ["install", "--silent"], { cwd: modulePath, timeout: 120000 });
+        return { ran: true, success: ok, type: "npm" };
+      }
+    } catch {}
+  }
+  const installSh = join10(modulePath, "install.sh");
+  if (existsSync9(installSh)) {
+    const ok = runArgs("bash", [installSh], { cwd: modulePath });
+    return { ran: true, success: ok, type: "script" };
+  }
+  try {
+    const entries = readdirSync3(modulePath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith("."))
+        continue;
+      const subPkg = join10(modulePath, entry.name, "package.json");
+      if (existsSync9(subPkg)) {
+        try {
+          const pkg = JSON.parse(readFileSync5(subPkg, "utf-8"));
+          if (pkg.dependencies || pkg.devDependencies) {
+            const ok = runArgs("npm", ["install", "--silent"], { cwd: join10(modulePath, entry.name), timeout: 120000 });
+            return { ran: true, success: ok, type: "npm" };
+          }
+        } catch {}
+      }
+    }
+  } catch {}
+  return { ran: false, success: true };
+}
+function countFiles(dir) {
+  let total = 0;
+  const byExt = {};
+  function walk(d) {
+    try {
+      for (const entry of readdirSync3(d, { withFileTypes: true })) {
+        if (entry.name.startsWith("."))
+          continue;
+        const fullPath = join10(d, entry.name);
+        if (entry.isFile()) {
+          total++;
+          const ext = entry.name.includes(".") ? entry.name.split(".").pop().toLowerCase() : "other";
+          byExt[ext] = (byExt[ext] || 0) + 1;
+        } else if (entry.isDirectory()) {
+          walk(fullPath);
+        }
+      }
+    } catch {}
+  }
+  walk(dir);
+  return { total, byExt };
+}
 function isInitialized() {
-  return existsSync7(DATACORE_DIR);
+  try {
+    return existsSync9(DATACORE_DIR) && existsSync9(join10(DATACORE_DIR, "agents")) && readdirSync3(join10(DATACORE_DIR, "agents")).length > 0 && existsSync9(join10(DATA_DIR8, "0-personal")) && existsSync9(join10(DATA_DIR8, ".git"));
+  } catch {
+    return false;
+  }
 }
 async function initDatacore(options = {}) {
-  const { nonInteractive = false, skipChecks = false, stream = false } = options;
+  const { nonInteractive = false, skipChecks = false, stream = false, verbose = false, force = false } = options;
   const isTTY = stream && process.stdout.isTTY;
   const interactive = isTTY && !nonInteractive;
+  const platform2 = detectPlatform();
   const result = {
     success: false,
     created: [],
@@ -9194,6 +9917,7 @@ async function initDatacore(options = {}) {
   };
   const op = startOperation("init", { options });
   op.start();
+  let profile = { name: "", email: "", useCase: "both", role: "" };
   try {
     if (isTTY) {
       console.clear();
@@ -9202,388 +9926,1081 @@ async function initDatacore(options = {}) {
       console.log();
       await sleep(300);
     }
-    op.addStep("check_dependencies");
-    op.startStep("check_dependencies");
+    op.addStep("about_you");
+    op.startStep("about_you");
+    if (interactive) {
+      section(`Step 1/${TOTAL_STEPS}: About You`);
+      console.log();
+      console.log(`  ${c2.dim}Let's personalize your setup. This configures your identity,${c2.reset}`);
+      console.log(`  ${c2.dim}AI context layer, and tailors the experience to your needs.${c2.reset}`);
+      console.log();
+      const gitConfig = isGitConfigured();
+      if (gitConfig.name)
+        profile.name = gitConfig.name;
+      if (gitConfig.email)
+        profile.email = gitConfig.email;
+      profile.name = await prompt(`  Your name`, profile.name || undefined);
+      profile.email = await prompt(`  Your email`, profile.email || undefined);
+      console.log();
+      console.log(`  ${c2.bold}How will you use Datacore?${c2.reset}`);
+      const useCaseIdx = await choose("  Choose", [
+        "Personal productivity (GTD, knowledge management, AI delegation)",
+        "Team management (projects, collaboration, shared knowledge)",
+        "Both personal and team use"
+      ], 2);
+      profile.useCase = ["personal", "team", "both"][useCaseIdx] ?? "both";
+      console.log();
+      profile.role = await prompt(`  Your role (e.g., developer, founder, researcher)`, "");
+      console.log();
+      console.log(`  ${c2.green}✓${c2.reset} Welcome, ${c2.bold}${profile.name || "friend"}${c2.reset}!`);
+      console.log();
+    } else {
+      const gitConfig = isGitConfigured();
+      if (gitConfig.name)
+        profile.name = gitConfig.name;
+      if (gitConfig.email)
+        profile.email = gitConfig.email;
+    }
+    op.completeStep("about_you");
+    op.addStep("system_setup");
+    op.startStep("system_setup");
     if (!skipChecks) {
       if (isTTY) {
-        section("Step 1: Checking Your System");
+        section(`Step 2/${TOTAL_STEPS}: System Setup`);
+        console.log();
+        console.log(`  ${c2.dim}Ensuring all tools are installed and configured.${c2.reset}`);
+        console.log(`  ${c2.dim}Datacore will install anything that's missing.${c2.reset}`);
         console.log();
       }
-      const doctor = runDoctor();
-      const gitStatus = checkGitDetailed();
-      if (isTTY) {
-        if (gitStatus.installed) {
-          console.log(`  ${c2.green}✓${c2.reset} git ${c2.dim}(${gitStatus.version})${c2.reset}`);
-          if (gitStatus.configured) {
-            console.log(`    ${c2.dim}Configured as: ${gitStatus.userName} <${gitStatus.userEmail}>${c2.reset}`);
-          } else {
-            console.log(`    ${c2.yellow}⚠${c2.reset} ${c2.yellow}Not configured. Run:${c2.reset}`);
-            console.log(`      ${c2.dim}git config --global user.name "Your Name"${c2.reset}`);
-            console.log(`      ${c2.dim}git config --global user.email "you@example.com"${c2.reset}`);
-            result.warnings.push("git not configured with user.name and user.email");
+      if (platform2 === "macos") {
+        if (!commandExists3("brew")) {
+          if (isTTY) {
+            console.log(`  ${c2.dim}Homebrew is needed to install system packages on macOS.${c2.reset}`);
+            console.log();
           }
-        } else {
-          console.log(`  ${c2.red}✗${c2.reset} git ${c2.red}(required)${c2.reset}`);
-          console.log(`    ${c2.dim}Version control for your knowledge system${c2.reset}`);
-          result.errors.push("git is required but not installed");
+          await ensureHomebrew(!!isTTY);
         }
-        if (gitStatus.githubAuth) {
-          console.log(`  ${c2.green}✓${c2.reset} GitHub ${c2.dim}(authenticated as ${gitStatus.githubUser})${c2.reset}`);
-        } else {
-          console.log(`  ${c2.yellow}○${c2.reset} GitHub ${c2.dim}(not authenticated)${c2.reset}`);
-          console.log(`    ${c2.dim}Optional: Install gh CLI and run 'gh auth login'${c2.reset}`);
+      }
+      const git = await ensureDependency("git", "git", platform2, !!isTTY);
+      if (git.available) {
+        if (!git.wasInstalled && isTTY) {
+          console.log(`  ${c2.green}✓${c2.reset} git ${c2.dim}(${git.version})${c2.reset}`);
         }
-        for (const dep of doctor.dependencies) {
-          if (dep.name === "git")
-            continue;
-          const info2 = {
-            "git-lfs": "Large file support (PDFs, images, videos)",
-            node: "Runtime for automation scripts",
-            python: "Powers AI agents and data processing",
-            claude: "Claude Code AI assistant"
-          };
-          if (dep.installed) {
-            console.log(`  ${c2.green}✓${c2.reset} ${dep.name} ${dep.version ? `${c2.dim}(${dep.version})${c2.reset}` : ""}`);
-          } else if (dep.required) {
-            console.log(`  ${c2.red}✗${c2.reset} ${dep.name} ${c2.red}(required)${c2.reset}`);
-            console.log(`    ${c2.dim}${info2[dep.name] || ""}${c2.reset}`);
-            if (dep.installCommand) {
-              console.log(`    ${c2.yellow}Install: ${dep.installCommand}${c2.reset}`);
-            }
+        const gitConfig = isGitConfigured();
+        if (!gitConfig.configured && profile.name && profile.email) {
+          if (isTTY) {
+            const spinner = new Spinner("Configuring git identity...");
+            spinner.start();
+            runArgs("git", ["config", "--global", "user.name", profile.name]);
+            runArgs("git", ["config", "--global", "user.email", profile.email]);
+            spinner.succeed(`Git configured as: ${profile.name} <${profile.email}>`);
           } else {
-            console.log(`  ${c2.yellow}○${c2.reset} ${dep.name} ${c2.dim}(recommended)${c2.reset}`);
-            console.log(`    ${c2.dim}${info2[dep.name] || ""}${c2.reset}`);
-            if (dep.installCommand) {
-              console.log(`    ${c2.dim}Install: ${dep.installCommand}${c2.reset}`);
-            }
+            runArgs("git", ["config", "--global", "user.name", profile.name]);
+            runArgs("git", ["config", "--global", "user.email", profile.email]);
           }
+        } else if (gitConfig.configured && interactive && profile.name && profile.email && (gitConfig.name !== profile.name || gitConfig.email !== profile.email)) {
+          console.log(`    ${c2.dim}Git configured as: ${gitConfig.name} <${gitConfig.email}>${c2.reset}`);
+          const override = await confirm(`    Update to ${profile.name} <${profile.email}>?`, false);
+          if (override) {
+            runArgs("git", ["config", "--global", "user.name", profile.name]);
+            runArgs("git", ["config", "--global", "user.email", profile.email]);
+            console.log(`  ${c2.green}✓${c2.reset} Git updated to: ${profile.name} <${profile.email}>`);
+          }
+        } else if (gitConfig.configured && isTTY && !git.wasInstalled) {
+          console.log(`    ${c2.dim}Configured as: ${gitConfig.name} <${gitConfig.email}>${c2.reset}`);
+        }
+      } else {
+        result.errors.push("git is required but could not be installed");
+      }
+      const node = await ensureDependency("node", "node", platform2, !!isTTY, "-v");
+      if (node.available && !node.wasInstalled && isTTY) {
+        console.log(`  ${c2.green}✓${c2.reset} node ${c2.dim}(${node.version})${c2.reset}`);
+      }
+      if (node.available && node.version) {
+        const major = parseInt(node.version.split(".")[0] || "0", 10);
+        if (major < 20) {
+          if (isTTY)
+            console.log(`    ${c2.yellow}⚠${c2.reset} ${c2.dim}Node ${node.version} is outdated. Consider updating to Node 20+${c2.reset}`);
+          result.warnings.push(`Node.js ${node.version} is outdated - recommend Node 20+`);
         }
-        console.log();
       }
-      if (doctor.status === "missing_required") {
-        const missing = doctor.dependencies.filter((d) => d.required && !d.installed);
-        for (const dep of missing) {
-          result.errors.push(`Missing required: ${dep.name}`);
+      const claude = await ensureDependency("claude", "claude", platform2, !!isTTY);
+      if (claude.available && !claude.wasInstalled && isTTY) {
+        console.log(`  ${c2.green}✓${c2.reset} Claude Code ${c2.dim}(${claude.version})${c2.reset}`);
+      }
+      if (!claude.available) {
+        result.warnings.push("Claude Code not installed - install with: npm install -g @anthropic-ai/claude-code");
+      }
+      const python = await ensureDependency("python", "python3", platform2, !!isTTY);
+      if (python.available && !python.wasInstalled && isTTY) {
+        console.log(`  ${c2.green}✓${c2.reset} python ${c2.dim}(${python.version})${c2.reset}`);
+      }
+      if (!python.available) {
+        result.warnings.push("Python not installed - some agents may not work");
+      }
+      const gh = await ensureDependency("gh", "gh", platform2, !!isTTY);
+      if (gh.available && !gh.wasInstalled && isTTY) {
+        const ghAuth2 = checkGhAuth();
+        if (ghAuth2.available) {
+          console.log(`  ${c2.green}✓${c2.reset} GitHub CLI ${c2.dim}(authenticated as ${ghAuth2.user})${c2.reset}`);
+        } else {
+          console.log(`  ${c2.green}✓${c2.reset} GitHub CLI ${c2.dim}(installed, not authenticated)${c2.reset}`);
         }
-        if (isTTY) {
-          console.log(`  ${c2.red}${c2.bold}Cannot continue - install required dependencies first.${c2.reset}`);
+      }
+      if (commandExists3("gh")) {
+        const ghAuth2 = checkGhAuth();
+        if (!ghAuth2.available && interactive) {
           console.log();
+          console.log(`  ${c2.dim}To connect your GitHub account, a browser window will open.${c2.reset}`);
+          const doAuth = await confirm("  Authenticate with GitHub now?", true);
+          if (doAuth) {
+            try {
+              execFileSync2("gh", ["auth", "login", "--web", "--git-protocol", "https"], {
+                stdio: "inherit",
+                timeout: 120000
+              });
+              const newAuth = checkGhAuth();
+              if (newAuth.available) {
+                console.log(`  ${c2.green}✓${c2.reset} GitHub authenticated (${newAuth.user})`);
+              }
+            } catch {
+              console.log(`  ${c2.yellow}⚠${c2.reset} GitHub authentication skipped`);
+              result.warnings.push("GitHub CLI not authenticated - fork workflow may not work");
+            }
+          } else {
+            result.warnings.push("GitHub CLI not authenticated - run: gh auth login");
+          }
         }
-        op.failStep("check_dependencies", "Missing required dependencies");
-        op.fail("Missing required dependencies");
-        return result;
       }
-      if (interactive && !gitStatus.configured) {
-        const proceed = await confirm("Git is not configured. Continue anyway?", false);
-        if (!proceed) {
-          result.errors.push("User cancelled: git not configured");
-          op.fail("User cancelled");
-          return result;
+      const gitlfs = await ensureDependency("git-lfs", "git-lfs", platform2, !!isTTY);
+      if (gitlfs.available && !gitlfs.wasInstalled && isTTY) {
+        console.log(`  ${c2.green}✓${c2.reset} git-lfs ${c2.dim}(${gitlfs.version})${c2.reset}`);
+      }
+      if (isTTY) {
+        console.log();
+        if (git.available && node.available) {
+          console.log(`  ${c2.green}All systems ready.${c2.reset}`);
+        } else {
+          console.log(`  ${c2.yellow}Some tools could not be installed. Continuing with what's available.${c2.reset}`);
         }
+        console.log();
       }
     }
-    op.completeStep("check_dependencies");
-    op.addStep("create_data_dir");
-    op.startStep("create_data_dir");
+    op.completeStep("system_setup");
+    op.addStep("clone_repo");
+    op.startStep("clone_repo");
     if (isTTY) {
-      section("Step 2: Creating ~/Data");
-      console.log(`  ${c2.dim}Your central knowledge directory. Everything lives here.${c2.reset}`);
+      section(`Step 3/${TOTAL_STEPS}: Setting Up Repository`);
+      console.log();
+      console.log(`  ${c2.dim}Datacore lives in ~/Data. We'll fork the main repository to your${c2.reset}`);
+      console.log(`  ${c2.dim}GitHub account so you can customize freely and pull updates.${c2.reset}`);
+      console.log();
+    }
+    const ghAuth = checkGhAuth();
+    const upstreamUrl = `https://github.com/${UPSTREAM_REPO}.git`;
+    let ghUser;
+    if (ghAuth.available) {
+      ghUser = ghAuth.user || runArgsOutput("gh", ["api", "user", "-q", ".login"], { timeout: 15000 });
+      const forkSpinner = isTTY ? new Spinner("Checking fork...") : null;
+      forkSpinner?.start();
+      const forkExists = runArgs("gh", ["repo", "view", `${ghUser}/datacore`], { cwd: process.env.HOME, timeout: 30000 });
+      if (!forkExists) {
+        forkSpinner?.update("Forking repository...");
+        const forked = runArgs("gh", ["repo", "fork", UPSTREAM_REPO, "--clone=false"], { timeout: 30000 });
+        if (forked) {
+          forkSpinner?.succeed(`Forked to ${ghUser}/datacore`);
+        } else {
+          forkSpinner?.fail("Fork failed (will clone upstream directly)");
+          result.warnings.push("Could not fork repository - will clone directly");
+          ghUser = undefined;
+        }
+      } else {
+        forkSpinner?.succeed(`Fork exists: ${ghUser}/datacore`);
+      }
+    }
+    const cloneUrls = [];
+    if (ghUser) {
+      cloneUrls.push(`https://github.com/${ghUser}/datacore.git`);
+      cloneUrls.push(`git@github.com:${ghUser}/datacore.git`);
+    }
+    if (!ghAuth.available && interactive) {
+      const customUrl = await prompt("  Repository URL", upstreamUrl);
+      cloneUrls.push(customUrl);
+      const sshUrl = customUrl.replace("https://github.com/", "git@github.com:");
+      if (sshUrl !== customUrl)
+        cloneUrls.push(sshUrl);
+    } else {
+      cloneUrls.push(upstreamUrl);
+      cloneUrls.push(`git@github.com:${UPSTREAM_REPO}.git`);
+    }
+    if (!ghAuth.available && interactive) {
+      console.log(`  ${c2.dim}GitHub CLI not authenticated. Cloning upstream directly.${c2.reset}`);
+      console.log(`  ${c2.dim}You can fork later with: gh repo fork --remote${c2.reset}`);
       console.log();
     }
-    if (!existsSync7(DATA_DIR5)) {
-      mkdirSync4(DATA_DIR5, { recursive: true });
-      result.created.push(DATA_DIR5);
+    const hasGitDir = existsSync9(join10(DATA_DIR8, ".git"));
+    const hasValidGit = hasGitDir && runArgs("git", ["rev-parse", "HEAD"], { cwd: DATA_DIR8, timeout: 5000 });
+    if (hasValidGit) {
       if (isTTY)
-        console.log(`  ${c2.green}✓${c2.reset} Created ${DATA_DIR5}`);
+        console.log(`  ${c2.green}✓${c2.reset} Found existing repository at ~/Data`);
+      const pullSpinner = isTTY ? new Spinner("Pulling latest changes...") : null;
+      pullSpinner?.start();
+      if (runArgs("git", ["pull", "--rebase", "--autostash"], { cwd: DATA_DIR8, timeout: 60000 })) {
+        pullSpinner?.succeed("Repository up to date");
+      } else {
+        pullSpinner?.fail("Pull failed (non-fatal, continuing)");
+        result.warnings.push("Could not pull latest changes");
+      }
+      const currentUpstream = runArgsOutput("git", ["remote", "get-url", "upstream"]);
+      if (!currentUpstream) {
+        runArgs("git", ["remote", "add", "upstream", upstreamUrl], { cwd: DATA_DIR8 });
+      }
     } else {
+      mkdirSync6(DATA_DIR8, { recursive: true });
+      const cloneSpinner = isTTY ? new Spinner("Cloning into ~/Data...") : null;
+      cloneSpinner?.start();
+      let lastCloneErr = "";
+      let cloned = false;
+      for (const url of cloneUrls) {
+        const r = runArgsWithError("git", ["clone", url, "."], { cwd: DATA_DIR8, timeout: 300000 });
+        if (r.ok) {
+          cloned = true;
+          break;
+        }
+        lastCloneErr = r.stderr || "";
+        if (lastCloneErr.includes("already exists and is not an empty directory"))
+          break;
+      }
+      if (cloned) {
+        cloneSpinner?.succeed("Cloned into ~/Data");
+        result.created.push(DATA_DIR8);
+        if (ghUser) {
+          runArgs("git", ["remote", "add", "upstream", upstreamUrl], { cwd: DATA_DIR8 });
+        }
+      } else if (lastCloneErr.includes("already exists and is not an empty directory")) {
+        if (!force) {
+          cloneSpinner?.fail("~/Data is not empty");
+          const entries = readdirSync3(DATA_DIR8);
+          if (isTTY) {
+            console.log(`    ${c2.dim}~/Data contains ${entries.length} items but is not a git repository.${c2.reset}`);
+            console.log(`    ${c2.dim}Use --force to initialize git in the existing directory.${c2.reset}`);
+            console.log(`    ${c2.dim}Or remove/rename ~/Data for a fresh install.${c2.reset}`);
+          }
+          result.errors.push("~/Data exists and is not empty. Use --force to re-initialize.");
+          op.failStep("clone_repo", "Directory not empty");
+          op.fail("~/Data is not empty");
+          return result;
+        }
+        cloneSpinner?.update("Initializing git in existing ~/Data...");
+        let initOk = false;
+        let lastInitErr = "";
+        for (const url of cloneUrls) {
+          const r = initGitInDir(url, DATA_DIR8);
+          if (r.ok) {
+            initOk = true;
+            break;
+          }
+          lastInitErr = r.stderr || "";
+        }
+        if (initOk) {
+          cloneSpinner?.succeed("Git initialized in existing ~/Data");
+          if (ghUser) {
+            runArgs("git", ["remote", "add", "upstream", upstreamUrl], { cwd: DATA_DIR8 });
+          }
+        } else {
+          cloneSpinner?.fail("Could not initialize git");
+          result.errors.push(`Git init failed: ${lastInitErr}`);
+          if (lastInitErr.includes("Authentication") || lastInitErr.includes("403") || lastInitErr.includes("401")) {
+            if (isTTY)
+              console.log(`    ${c2.dim}Check your GitHub access: gh auth status${c2.reset}`);
+          }
+          op.failStep("clone_repo", "Git init failed");
+          op.fail("Git init failed");
+          return result;
+        }
+      } else {
+        cloneSpinner?.fail("Clone failed");
+        if (lastCloneErr.includes("not found") || lastCloneErr.includes("not exist") || lastCloneErr.includes("does not appear to be a git repository")) {
+          result.errors.push("Repository not found");
+          if (isTTY) {
+            if (ghUser) {
+              console.log(`    ${c2.dim}Neither ${ghUser}/datacore nor ${UPSTREAM_REPO} could be cloned.${c2.reset}`);
+            }
+            console.log(`    ${c2.dim}Ensure you have access to ${UPSTREAM_REPO} and try again.${c2.reset}`);
+            console.log(`    ${c2.dim}Check access: gh repo view ${UPSTREAM_REPO}${c2.reset}`);
+          }
+        } else if (lastCloneErr.includes("Authentication") || lastCloneErr.includes("Permission") || lastCloneErr.includes("403") || lastCloneErr.includes("401")) {
+          result.errors.push("Authentication failed");
+          if (isTTY) {
+            console.log(`    ${c2.dim}Could not authenticate with GitHub.${c2.reset}`);
+            console.log(`    ${c2.dim}Try: gh auth login${c2.reset}`);
+          }
+        } else {
+          result.errors.push(`Clone failed: ${lastCloneErr}`);
+        }
+        op.failStep("clone_repo", "Clone failed");
+        op.fail("Clone failed");
+        return result;
+      }
+    }
+    const dipsDir = join10(DATACORE_DIR, "dips");
+    if (existsSync9(DATACORE_DIR) && !existsSync9(join10(dipsDir, ".git"))) {
+      const spinner = isTTY ? new Spinner("Fetching specifications...") : null;
+      spinner?.start();
+      const dipsRepo = "https://github.com/datacore-one/datacore-dips.git";
+      let clonedDips = runArgs("git", ["clone", dipsRepo, dipsDir], { timeout: 300000 });
+      if (!clonedDips) {
+        clonedDips = runArgs("git", ["clone", "git@github.com:datacore-one/datacore-dips.git", dipsDir], { timeout: 300000 });
+      }
+      if (clonedDips) {
+        spinner?.succeed("Specifications installed");
+      } else {
+        spinner?.fail("Could not fetch specifications (non-fatal)");
+        result.warnings.push("Specifications repo not cloned");
+      }
+    } else if (existsSync9(join10(dipsDir, ".git"))) {
       if (isTTY)
-        console.log(`  ${c2.green}✓${c2.reset} Found ${DATA_DIR5}`);
+        console.log(`  ${c2.green}✓${c2.reset} Specifications present`);
+    }
+    if (commandExists3("git-lfs") && existsSync9(join10(DATA_DIR8, ".git"))) {
+      const spinner = isTTY ? new Spinner("Initializing Git LFS...") : null;
+      spinner?.start();
+      if (runArgs("git", ["lfs", "install"], { cwd: DATA_DIR8, timeout: 30000 })) {
+        runArgs("git", ["lfs", "pull"], { cwd: DATA_DIR8, timeout: 120000 });
+        spinner?.succeed("Git LFS initialized");
+      } else {
+        spinner?.fail("Git LFS init failed (non-fatal)");
+      }
     }
     if (isTTY)
       console.log();
-    op.completeStep("create_data_dir");
-    op.addStep("create_datacore_dir");
-    op.startStep("create_datacore_dir");
+    op.completeStep("clone_repo");
+    op.addStep("team_spaces");
+    op.startStep("team_spaces");
+    if (interactive) {
+      section(`Step 4/${TOTAL_STEPS}: Team Spaces`);
+      console.log();
+      console.log(`  ${c2.dim}Spaces separate different areas of your life. Your personal space${c2.reset}`);
+      console.log(`  ${c2.dim}(0-personal) is created automatically. Team spaces are separate${c2.reset}`);
+      console.log(`  ${c2.dim}git repos for organizations you work with.${c2.reset}`);
+      console.log();
+      if (profile.useCase === "personal") {
+        console.log(`  ${c2.dim}You selected personal use. You can add team spaces anytime later:${c2.reset}`);
+        console.log(`    ${c2.dim}datacore space create <name>${c2.reset}`);
+      } else {
+        console.log(`  ${c2.dim}Each team space gets its own:${c2.reset}`);
+        console.log(`    ${c2.dim}• GTD task system and AI agents${c2.reset}`);
+        console.log(`    ${c2.dim}• Knowledge base (wiki, notes, research)${c2.reset}`);
+        console.log(`    ${c2.dim}• Project tracking via GitHub Issues${c2.reset}`);
+        console.log();
+        const existingSpaces = listSpaces();
+        const existingNames = existingSpaces.map((s) => s.name.replace(/^\d+-/, ""));
+        if (existingSpaces.length > 1) {
+          console.log(`  ${c2.dim}Existing spaces:${c2.reset}`);
+          for (const s of existingSpaces) {
+            console.log(`    ${s.type === "personal" ? "\uD83D\uDC64" : "\uD83D\uDC65"} ${s.name}`);
+          }
+          console.log();
+        }
+        const wantSpace = await confirm("  Would you like to add a team space?", false);
+        if (wantSpace) {
+          let adding = true;
+          while (adding) {
+            const spaceName = await prompt('  Space name (e.g., "datafund", "acme-corp")');
+            if (!spaceName) {
+              adding = false;
+              continue;
+            }
+            const normalized = spaceName.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+            const knownMatch = KNOWN_SPACES.find((ks) => ks.name === normalized || ks.displayName.toLowerCase() === spaceName.toLowerCase() || normalized.length >= 3 && ks.name.startsWith(normalized) || normalized.length >= 3 && ks.displayName.toLowerCase().startsWith(normalized.toLowerCase()));
+            if (existingNames.includes(normalized) || existingNames.includes(knownMatch?.name ?? "")) {
+              console.log(`  ${c2.green}✓${c2.reset} ${spaceName} is already installed`);
+              adding = await confirm("  Add another?", false);
+              continue;
+            }
+            if (knownMatch) {
+              console.log(`  ${c2.green}✓${c2.reset} Found registered space: ${c2.bold}${knownMatch.displayName}${c2.reset}`);
+              console.log(`    ${c2.dim}${knownMatch.description}${c2.reset}`);
+              const currentSpaces = listSpaces();
+              const nextNum = currentSpaces.length > 0 ? Math.max(...currentSpaces.map((s) => s.number)) + 1 : 1;
+              const spacePath = join10(DATA_DIR8, `${nextNum}-${knownMatch.name}`);
+              const spinner = new Spinner(`Cloning ${knownMatch.displayName}...`);
+              spinner.start();
+              let cloned = runArgs("git", ["clone", knownMatch.repo, spacePath], { timeout: 300000 });
+              if (!cloned) {
+                const sshUrl = knownMatch.repo.replace("https://github.com/", "git@github.com:");
+                cloned = runArgs("git", ["clone", sshUrl, spacePath], { timeout: 300000 });
+              }
+              if (cloned) {
+                spinner.succeed(`Added space: ${nextNum}-${knownMatch.name}`);
+                result.spacesCreated.push(`${nextNum}-${knownMatch.name}`);
+              } else {
+                spinner.fail(`Could not clone ${knownMatch.displayName}`);
+                if (knownMatch.private) {
+                  console.log(`    ${c2.dim}This is a private repo. Make sure you have access to ${knownMatch.org}.${c2.reset}`);
+                  console.log(`    ${c2.dim}Request access or try: gh auth refresh -s read:org${c2.reset}`);
+                }
+                result.warnings.push(`Failed to add space: ${knownMatch.name}`);
+              }
+            } else {
+              const repoUrl = await prompt("  Git repo URL (or Enter to create local)", "");
+              if (repoUrl) {
+                const currentSpaces = listSpaces();
+                const nextNum = currentSpaces.length > 0 ? Math.max(...currentSpaces.map((s) => s.number)) + 1 : 1;
+                const spacePath = join10(DATA_DIR8, `${nextNum}-${normalized}`);
+                const spinner = new Spinner(`Cloning ${spaceName}...`);
+                spinner.start();
+                let cloned = runArgs("git", ["clone", repoUrl, spacePath], { timeout: 300000 });
+                if (!cloned) {
+                  const sshUrl = repoUrl.replace("https://github.com/", "git@github.com:");
+                  cloned = runArgs("git", ["clone", sshUrl, spacePath], { timeout: 300000 });
+                }
+                if (cloned) {
+                  spinner.succeed(`Added space: ${nextNum}-${normalized}`);
+                  result.spacesCreated.push(`${nextNum}-${normalized}`);
+                } else {
+                  spinner.fail(`Could not clone ${repoUrl}`);
+                  result.warnings.push(`Failed to add space: ${spaceName}`);
+                }
+              } else {
+                try {
+                  const { createSpace: createSpace2 } = await Promise.resolve().then(() => (init_space(), exports_space));
+                  const space = createSpace2(spaceName, "team");
+                  result.created.push(space.path);
+                  result.spacesCreated.push(space.name);
+                  console.log(`  ${c2.green}✓${c2.reset} Created ${space.name}/`);
+                } catch (err) {
+                  console.log(`  ${c2.red}✗${c2.reset} ${err.message}`);
+                }
+              }
+            }
+            adding = await confirm("  Add another?", false);
+          }
+        }
+      }
+      console.log();
+    }
+    op.completeStep("team_spaces");
+    op.addStep("second_brain");
+    op.startStep("second_brain");
     if (isTTY) {
-      section("Step 3: Creating .datacore");
-      console.log(`  ${c2.dim}System configuration, agents, commands, and modules.${c2.reset}`);
+      section(`Step 5/${TOTAL_STEPS}: Your Second Brain`);
+      console.log();
+      console.log(`  ${c2.dim}Your personal space is your AI-powered second brain. Here's how${c2.reset}`);
+      console.log(`  ${c2.dim}it's organized:${c2.reset}`);
+      console.log();
+      console.log(`  ${c2.bold}Getting Things Done (GTD)${c2.reset}`);
+      console.log(`  ${c2.dim}A trusted system where you capture everything into an inbox, then${c2.reset}`);
+      console.log(`  ${c2.dim}process it into actionable next steps. Nothing stays in your head.${c2.reset}`);
+      console.log(`    ${c2.dim}• org/inbox.org         → Capture anything, anytime${c2.reset}`);
+      console.log(`    ${c2.dim}• org/next_actions.org  → What you're actually doing${c2.reset}`);
+      console.log(`    ${c2.dim}• org/someday.org       → Ideas for later${c2.reset}`);
+      console.log();
+      console.log(`  ${c2.bold}AI Delegation${c2.reset}`);
+      console.log(`  ${c2.dim}Tag tasks with :AI: and agents handle them overnight:${c2.reset}`);
+      console.log(`    ${c2.dim}• :AI:research:  → Deep research on any topic${c2.reset}`);
+      console.log(`    ${c2.dim}• :AI:content:   → Draft emails, blog posts, docs${c2.reset}`);
+      console.log(`    ${c2.dim}• :AI:data:      → Analyze data, generate reports${c2.reset}`);
+      console.log(`    ${c2.dim}• :AI:pm:        → Track projects, flag blockers${c2.reset}`);
+      console.log();
+      console.log(`  ${c2.bold}Knowledge Management${c2.reset}`);
+      console.log(`  ${c2.dim}Your knowledge compounds over time. Every note, insight, and${c2.reset}`);
+      console.log(`  ${c2.dim}conversation gets woven into a personal knowledge base:${c2.reset}`);
+      console.log(`    ${c2.dim}• notes/          → Daily journals, quick captures${c2.reset}`);
+      console.log(`    ${c2.dim}• 3-knowledge/    → Permanent knowledge (Zettelkasten)${c2.reset}`);
+      console.log(`      ${c2.dim}├── zettel/     → Atomic ideas, one concept per note${c2.reset}`);
+      console.log(`      ${c2.dim}├── pages/      → Longer topic pages and guides${c2.reset}`);
+      console.log(`      ${c2.dim}├── literature/ → Summaries of things you've read${c2.reset}`);
+      console.log(`      ${c2.dim}└── reference/  → People, companies, glossary${c2.reset}`);
+      console.log();
+      console.log(`  ${c2.dim}The more you capture, the smarter your system becomes. Agents${c2.reset}`);
+      console.log(`  ${c2.dim}cross-reference your knowledge to give better answers over time.${c2.reset}`);
       console.log();
     }
-    if (!existsSync7(DATACORE_DIR)) {
-      const dirs = [
-        { path: "", desc: "" },
-        { path: "commands", desc: "Slash commands (/today, /sync, etc.)" },
-        { path: "agents", desc: "AI agents for task automation" },
-        { path: "modules", desc: "Optional extensions" },
-        { path: "specs", desc: "System documentation" },
-        { path: "lib", desc: "Shared utilities" },
-        { path: "env", desc: "API keys and secrets" },
-        { path: "state", desc: "Runtime state" },
-        { path: "registry", desc: "Agent/command discovery" }
-      ];
-      for (const { path: dir, desc } of dirs) {
-        const path = join7(DATACORE_DIR, dir);
-        mkdirSync4(path, { recursive: true });
-        result.created.push(path);
-        if (isTTY && dir) {
-          console.log(`  ${c2.green}✓${c2.reset} ${dir}/ ${c2.dim}- ${desc}${c2.reset}`);
+    const personalPath = join10(DATA_DIR8, "0-personal");
+    if (existsSync9(personalPath)) {
+      if (isTTY)
+        console.log(`  ${c2.green}✓${c2.reset} Personal space ready (0-personal/)`);
+      result.spacesCreated.push("0-personal");
+    } else {
+      if (isTTY)
+        console.log(`  ${c2.dim}Creating personal space...${c2.reset}`);
+      try {
+        const { createSpace: createSpace2 } = await Promise.resolve().then(() => (init_space(), exports_space));
+        const space = createSpace2("personal", "personal");
+        result.created.push(space.path);
+        result.spacesCreated.push("0-personal");
+        if (isTTY)
+          console.log(`  ${c2.green}✓${c2.reset} Personal space created (0-personal/)`);
+      } catch {
+        const dirs = ["org", "notes", "notes/journals", "notes/pages", "journal", "3-knowledge", "content", "0-inbox"];
+        for (const dir of dirs) {
+          mkdirSync6(join10(personalPath, dir), { recursive: true });
         }
+        result.created.push(personalPath);
+        result.spacesCreated.push("0-personal");
+        if (isTTY)
+          console.log(`  ${c2.green}✓${c2.reset} Personal space initialized`);
       }
-      writeFileSync4(join7(DATACORE_DIR, "settings.yaml"), `# Datacore Settings
-# Override in settings.local.yaml (gitignored)
-
-editor:
-  open_markdown_on_generate: true
-  open_command: ""
-
-sync:
-  pull_on_today: true
-  push_on_wrap_up: true
-
-journal:
-  open_after_update: false
-
-nightshift:
-  server: ""
-  auto_trigger: false
-`);
-      result.created.push(join7(DATACORE_DIR, "settings.yaml"));
-      writeFileSync4(join7(DATACORE_DIR, "registry", "agents.yaml"), `# Agent Registry
-agents: []
+    }
+    const gtdFiles = ["inbox.org", "next_actions.org", "someday.org"];
+    const orgDir = join10(personalPath, "org");
+    let gtdReady = true;
+    for (const file of gtdFiles) {
+      if (!existsSync9(join10(orgDir, file)))
+        gtdReady = false;
+    }
+    if (gtdReady) {
+      if (isTTY)
+        console.log(`  ${c2.green}✓${c2.reset} GTD system initialized`);
+    }
+    if (existsSync9(join10(personalPath, "3-knowledge"))) {
+      if (isTTY)
+        console.log(`  ${c2.green}✓${c2.reset} Knowledge base ready`);
+    }
+    const templates = [
+      { src: "install.yaml.example", dst: "install.yaml", label: "Installation manifest" },
+      { src: "0-personal/org/inbox.org.example", dst: "0-personal/org/inbox.org", label: "GTD inbox" },
+      { src: "0-personal/org/next_actions.org.example", dst: "0-personal/org/next_actions.org", label: "GTD next actions" },
+      { src: "0-personal/org/someday.org.example", dst: "0-personal/org/someday.org", label: "GTD someday" },
+      { src: "0-personal/org/habits.org.example", dst: "0-personal/org/habits.org", label: "GTD habits" }
+    ];
+    for (const { src, dst } of templates) {
+      const srcPath = join10(DATA_DIR8, src);
+      const dstPath = join10(DATA_DIR8, dst);
+      if (existsSync9(srcPath) && !existsSync9(dstPath)) {
+        copyFileSync(srcPath, dstPath);
+        result.created.push(dstPath);
+      }
+    }
+    if (isTTY)
+      console.log(`  ${c2.green}✓${c2.reset} Templates activated`);
+    const claudeLocalPath = join10(DATA_DIR8, "CLAUDE.local.md");
+    if (!existsSync9(claudeLocalPath)) {
+      const localContent = [
+        `<!-- PRIVATE LAYER - This file is gitignored and never shared -->`,
+        ``,
+        `# ${profile.name || "My"}'s Datacore`,
+        ``,
+        profile.role ? `Role: ${profile.role}` : "",
+        ``,
+        `## My Workflow`,
+        ``,
+        `<!-- Add your personal workflow notes, preferences, and shortcuts here. -->`,
+        `<!-- This file is gitignored and only visible to your local Claude Code. -->`,
+        ``,
+        `## Custom Context`,
+        ``,
+        `<!-- Any private context that helps Claude assist you better: -->`,
+        `<!-- - Project abbreviations and shorthand -->`,
+        `<!-- - Personal communication preferences -->`,
+        `<!-- - Domain expertise and background -->`,
+        ``
+      ].filter(Boolean).join(`
 `);
-      writeFileSync4(join7(DATACORE_DIR, "registry", "commands.yaml"), `# Command Registry
-commands: []
+      writeFileSync5(claudeLocalPath, localContent);
+      result.created.push(claudeLocalPath);
+      if (isTTY)
+        console.log(`  ${c2.green}✓${c2.reset} CLAUDE.local.md created (your private AI context)`);
+    }
+    const settingsLocalPath = join10(DATACORE_DIR, "settings.local.yaml");
+    if (existsSync9(DATACORE_DIR) && !existsSync9(settingsLocalPath)) {
+      const settingsContent = [
+        `# Personal Settings Overrides (gitignored)`,
+        `# See settings.yaml for all available options`,
+        ``,
+        `editor:`,
+        `  open_markdown_on_generate: false`,
+        ``,
+        `sync:`,
+        `  pull_on_today: true`,
+        `  push_on_wrap_up: true`,
+        ``
+      ].join(`
 `);
-      if (isTTY) {
-        console.log();
-        console.log(`  ${c2.green}✓${c2.reset} Created settings.yaml`);
-        console.log(`    ${c2.dim}Customize in settings.local.yaml${c2.reset}`);
-      }
-    } else {
+      writeFileSync5(settingsLocalPath, settingsContent);
+      result.created.push(settingsLocalPath);
       if (isTTY)
-        console.log(`  ${c2.green}✓${c2.reset} Found existing .datacore/`);
+        console.log(`  ${c2.green}✓${c2.reset} settings.local.yaml created (your preferences)`);
     }
     if (isTTY)
       console.log();
-    op.completeStep("create_datacore_dir");
-    op.addStep("create_personal_space");
-    op.startStep("create_personal_space");
+    op.completeStep("second_brain");
+    op.addStep("modules");
+    op.startStep("modules");
     if (isTTY) {
-      section("Step 4: Creating Personal Space");
-      console.log(`  ${c2.dim}Your personal GTD system and knowledge base.${c2.reset}`);
+      section(`Step 6/${TOTAL_STEPS}: Modules`);
+      console.log();
+      console.log(`  ${c2.dim}Modules extend Datacore with specialized capabilities. Each adds${c2.reset}`);
+      console.log(`  ${c2.dim}new AI agents and /commands you can use in Claude Code.${c2.reset}`);
       console.log();
     }
-    const existingSpaces = listSpaces();
-    const hasPersonal = existingSpaces.some((s) => s.number === 0);
-    if (!hasPersonal) {
-      const space = createSpace("personal", "personal");
-      result.created.push(space.path);
-      result.spacesCreated.push(space.name);
-      if (isTTY) {
-        console.log(`  ${c2.green}✓${c2.reset} Created 0-personal/`);
-        console.log();
-        console.log(`  ${c2.bold}GTD System (org/):${c2.reset}`);
-        console.log(`    ${c2.cyan}inbox.org${c2.reset} ${c2.dim}- Capture everything here${c2.reset}`);
-        console.log(`    ${c2.cyan}next_actions.org${c2.reset} ${c2.dim}- Tasks by focus area${c2.reset}`);
-        console.log(`    ${c2.cyan}nightshift.org${c2.reset} ${c2.dim}- AI task queue (overnight)${c2.reset}`);
-        console.log(`    ${c2.cyan}habits.org${c2.reset} ${c2.dim}- Daily/weekly routines${c2.reset}`);
-        console.log(`    ${c2.cyan}someday.org${c2.reset} ${c2.dim}- Future ideas${c2.reset}`);
-        console.log();
-        console.log(`  ${c2.bold}Knowledge:${c2.reset}`);
-        console.log(`    ${c2.cyan}notes/${c2.reset} ${c2.dim}- Personal wiki (Obsidian)${c2.reset}`);
-        console.log(`    ${c2.cyan}3-knowledge/${c2.reset} ${c2.dim}- Zettelkasten structure${c2.reset}`);
-        console.log();
-        console.log(`  ${c2.bold}AI Delegation:${c2.reset}`);
-        console.log(`    ${c2.dim}Tag tasks with :AI: to delegate:${c2.reset}`);
-        console.log(`    ${c2.dim}:AI:research: :AI:content: :AI:data: :AI:pm:${c2.reset}`);
+    const modulesDir = join10(DATACORE_DIR, "modules");
+    if (existsSync9(DATACORE_DIR)) {
+      mkdirSync6(modulesDir, { recursive: true });
+    }
+    const installedNames = listModules().map((m) => m.name);
+    const allModules = AVAILABLE_MODULES;
+    let modulesToInstall = [];
+    if (interactive) {
+      console.log(`  ${c2.dim}All modules are selected by default. Deselect any you don't need:${c2.reset}`);
+      console.log();
+      const selected = new Set(allModules.map((_, i) => i));
+      for (let i = 0;i < allModules.length; i++) {
+        const mod = allModules[i];
+        const isInstalled = installedNames.includes(mod.name);
+        const coreLabel = mod.core ? ` ${c2.dim}(core)${c2.reset}` : "";
+        const installedLabel = isInstalled ? ` ${c2.dim}(installed)${c2.reset}` : "";
+        const num = String(i + 1).padStart(2, " ");
+        console.log(`  [x] ${c2.cyan}${num}${c2.reset}. ${c2.bold}${mod.name.padEnd(12)}${c2.reset} ${mod.description}${coreLabel}${installedLabel}`);
+      }
+      console.log();
+      const removeInput = await prompt("  Enter numbers to REMOVE, or press Enter to install all", "");
+      if (removeInput) {
+        const nums = removeInput.split(/[,\s]+/).map((s) => parseInt(s.trim(), 10));
+        for (const n of nums) {
+          if (n >= 1 && n <= allModules.length) {
+            const mod = allModules[n - 1];
+            if (!mod.core) {
+              selected.delete(n - 1);
+            }
+          }
+        }
       }
+      modulesToInstall = allModules.filter((_, i) => selected.has(i));
     } else {
-      if (isTTY) {
-        console.log(`  ${c2.green}✓${c2.reset} Found existing personal space`);
+      modulesToInstall = [...allModules];
+    }
+    let installCount = 0;
+    for (const mod of modulesToInstall) {
+      if (installedNames.includes(mod.name)) {
+        installCount++;
+        continue;
+      }
+      const spinner = isTTY ? new Spinner(`Installing ${mod.name}...`) : null;
+      spinner?.start();
+      try {
+        await sleep(100);
+        const info2 = installModule(mod.repo);
+        result.modulesInstalled.push(mod.name);
+        installCount++;
+        const postInstall = runModulePostInstall(info2.path);
+        if (postInstall.ran && postInstall.success) {
+          spinner?.succeed(`${mod.name} - dependencies installed (${postInstall.type})`);
+        } else if (postInstall.ran && !postInstall.success) {
+          spinner?.succeed(`${mod.name}`);
+          if (isTTY)
+            console.log(`    ${c2.yellow}⚠${c2.reset} ${c2.dim}Dependency install failed (${postInstall.type})${c2.reset}`);
+        } else {
+          spinner?.succeed(mod.name);
+        }
+      } catch (err) {
+        spinner?.fail(`${mod.name} - ${err.message}`);
+        result.warnings.push(`Module ${mod.name} failed to install: ${err.message}`);
+      }
+    }
+    if (isTTY) {
+      console.log();
+      console.log(`  ${c2.green}${installCount} modules installed.${c2.reset}`);
+      console.log();
+    }
+    op.completeStep("modules");
+    op.addStep("finalize");
+    op.startStep("finalize");
+    if (isTTY) {
+      section(`Step 7/${TOTAL_STEPS}: Finalize`);
+      console.log();
+    }
+    const contextMerge = join10(DATACORE_DIR, "lib", "context_merge.py");
+    if (existsSync9(contextMerge)) {
+      const spinner = isTTY ? new Spinner("Building CLAUDE.md from layers...") : null;
+      spinner?.start();
+      if (runArgs("python3", [contextMerge, "rebuild", "--path", DATA_DIR8, "--all"])) {
+        spinner?.succeed("CLAUDE.md built from layers (all spaces)");
+      } else {
+        spinner?.fail("CLAUDE.md build failed (can rebuild later)");
+        result.warnings.push("Could not build CLAUDE.md");
+      }
+    }
+    const zettelDb = join10(DATACORE_DIR, "lib", "zettel_db.py");
+    if (existsSync9(zettelDb)) {
+      const spinner = isTTY ? new Spinner("Initializing knowledge database...") : null;
+      spinner?.start();
+      if (runArgs("python3", [zettelDb, "init-all"], { cwd: DATA_DIR8 })) {
+        spinner?.succeed("Knowledge database initialized");
+      } else {
+        spinner?.fail("Database init failed (non-fatal)");
+        result.warnings.push("Database initialization failed");
+      }
+    }
+    if (existsSync9(DATACORE_DIR)) {
+      const stateDir = join10(DATACORE_DIR, "state");
+      const envDir = join10(DATACORE_DIR, "env");
+      mkdirSync6(stateDir, { recursive: true });
+      mkdirSync6(envDir, { recursive: true });
+      if (!existsSync9(join10(stateDir, ".gitkeep")))
+        writeFileSync5(join10(stateDir, ".gitkeep"), "");
+      if (!existsSync9(join10(envDir, ".gitkeep")))
+        writeFileSync5(join10(envDir, ".gitkeep"), "");
+      if (isTTY)
+        console.log(`  ${c2.green}✓${c2.reset} Runtime directories ready`);
+    }
+    const claudeDir = join10(DATA_DIR8, ".claude");
+    if (!existsSync9(claudeDir) && existsSync9(DATACORE_DIR)) {
+      try {
+        symlinkSync(DATACORE_DIR, claudeDir);
+        result.created.push(claudeDir);
+      } catch {}
+    }
+    const syncScript = join10(DATA_DIR8, "sync");
+    if (existsSync9(syncScript)) {
+      if (platform2 !== "windows") {
+        runArgs("chmod", ["+x", syncScript]);
+      }
+      if (isTTY)
+        console.log(`  ${c2.green}✓${c2.reset} Sync script configured`);
+    }
+    const installYaml = join10(DATA_DIR8, "install.yaml");
+    if (existsSync9(installYaml) || existsSync9(DATACORE_DIR)) {
+      try {
+        const allSpaces = listSpaces();
+        const allInstalledModules = listModules();
+        const spacesYaml = allSpaces.filter((s) => s.type !== "personal").map((s) => `  ${s.name}:
+    path: ${s.name}`).join(`
+`);
+        const modulesYaml = allInstalledModules.map((m) => `  - ${m.name}`).join(`
+`);
+        const yamlContent = [
+          `# Datacore Installation Manifest`,
+          `# Generated by: datacore init`,
+          `# Date: ${new Date().toISOString().split("T")[0]}`,
+          ``,
+          `meta:`,
+          `  name: "${profile.name ? `${profile.name}'s Datacore` : "My Datacore"}"`,
+          `  root: "${DATA_DIR8}"`,
+          `  version: 1.0.0`,
+          profile.role ? `  role: "${profile.role}"` : null,
+          `  use_case: ${profile.useCase}`,
+          ``,
+          `modules:`,
+          modulesYaml || "  []",
+          ``,
+          `personal:`,
+          `  path: 0-personal`,
+          ``,
+          `spaces:`,
+          spacesYaml || "  {}",
+          ``
+        ].filter((line) => line !== null).join(`
+`);
+        writeFileSync5(installYaml, yamlContent);
+        if (isTTY)
+          console.log(`  ${c2.green}✓${c2.reset} install.yaml saved`);
+      } catch {
+        result.warnings.push("Could not update install.yaml");
       }
     }
+    try {
+      const snapshot = createSnapshot();
+      saveSnapshot(snapshot);
+      if (isTTY)
+        console.log(`  ${c2.green}✓${c2.reset} Snapshot created (datacore.lock.yaml)`);
+    } catch {
+      result.warnings.push("Could not create snapshot");
+    }
     if (isTTY)
       console.log();
-    op.completeStep("create_personal_space");
+    op.completeStep("finalize");
+    op.addStep("import_data");
+    op.startStep("import_data");
+    const backgroundJobs = [];
+    const canBackgroundIngest = commandExists3("datacore") && commandExists3("claude");
     if (interactive) {
-      section("Step 5: Additional Spaces");
-      console.log(`  ${c2.dim}Spaces separate different areas of your life (work, projects, teams).${c2.reset}`);
-      console.log(`  ${c2.dim}Each space is a separate git repo with its own GTD system.${c2.reset}`);
+      section(`Step 8/${TOTAL_STEPS}: Import Your Data`);
       console.log();
-      const wantMoreSpaces = await confirm("Would you like to create additional spaces?", false);
-      if (wantMoreSpaces) {
-        let creating = true;
-        while (creating) {
-          const name = await prompt('Space name (e.g., "work", "acme-corp")');
-          if (!name) {
-            creating = false;
-            continue;
+      console.log(`  ${c2.dim}Your second brain works best when it has your existing knowledge.${c2.reset}`);
+      console.log(`  ${c2.dim}You can import data now or do it later with 'datacore ingest'.${c2.reset}`);
+      console.log();
+      let importing = true;
+      let totalImported = 0;
+      const inboxDir = join10(DATA_DIR8, "0-personal", "0-inbox");
+      mkdirSync6(inboxDir, { recursive: true });
+      const IMPORT_SKIP = 4;
+      while (importing) {
+        console.log(`  ${c2.dim}Common sources to import:${c2.reset}`);
+        console.log(`    ${c2.cyan}1${c2.reset}) ChatGPT conversation exports (JSON)`);
+        console.log(`    ${c2.cyan}2${c2.reset}) Documents folder (PDFs, Word docs, markdown)`);
+        console.log(`    ${c2.cyan}3${c2.reset}) Existing notes (Obsidian, Notion export, etc.)`);
+        console.log(`    ${c2.cyan}4${c2.reset}) Skip for now`);
+        console.log();
+        const choice = await prompt("  What would you like to import?", "4");
+        const choiceNum = parseInt(choice, 10);
+        if (choiceNum === IMPORT_SKIP || !choice) {
+          if (totalImported === 0) {
+            console.log();
+            console.log(`  ${c2.dim}No problem! You can import data anytime:${c2.reset}`);
+            console.log(`    ${c2.dim}datacore ingest ~/path/to/files${c2.reset}`);
+            console.log(`    ${c2.dim}datacore ingest ~/Downloads/chatgpt-export.json${c2.reset}`);
           }
-          try {
-            const space = createSpace(name, "team");
-            result.created.push(space.path);
-            result.spacesCreated.push(space.name);
-            console.log(`  ${c2.green}✓${c2.reset} Created ${space.name}/`);
-          } catch (err) {
-            console.log(`  ${c2.red}✗${c2.reset} ${err.message}`);
+          importing = false;
+          continue;
+        }
+        if (choiceNum === 1) {
+          const chatPath = await prompt("  Path to ChatGPT export");
+          const chatResolved = chatPath?.startsWith("~") ? join10(process.env.HOME || "", chatPath.slice(1)) : chatPath;
+          if (chatResolved && existsSync9(chatResolved)) {
+            const resolvedPath = chatResolved;
+            const spinner = new Spinner("Processing ChatGPT export...");
+            spinner.start();
+            try {
+              const content = readFileSync5(resolvedPath, "utf-8");
+              const data = JSON.parse(content);
+              const count = Array.isArray(data) ? data.length : 1;
+              const destName = `chatgpt-export-${Date.now()}.json`;
+              const destPath = join10(inboxDir, destName);
+              copyFileSync(resolvedPath, destPath);
+              if (canBackgroundIngest) {
+                const job = spawnBackground("datacore", ["ingest", destPath], "ingest");
+                if (job) {
+                  backgroundJobs.push(job);
+                  const bgOp = startOperation("background-ingest", { pid: job.pid, logFile: job.logFile, path: destPath });
+                  bgOp.start();
+                  spinner.succeed(`Found ${count} conversations - queued for background processing`);
+                } else {
+                  spinner.succeed(`Found ${count} conversations - copied to inbox`);
+                  console.log(`    ${c2.dim}Process with: datacore ingest ${destPath}${c2.reset}`);
+                }
+              } else {
+                spinner.succeed(`Found ${count} conversations - copied to inbox`);
+                console.log(`    ${c2.dim}Process with /ingest in Claude Code for full knowledge extraction${c2.reset}`);
+              }
+              totalImported += count;
+            } catch {
+              spinner.fail("Could not parse ChatGPT export");
+              try {
+                const fallbackDest = join10(inboxDir, basename5(resolvedPath));
+                copyFileSync(resolvedPath, fallbackDest);
+                if (canBackgroundIngest) {
+                  const job = spawnBackground("datacore", ["ingest", fallbackDest], "ingest");
+                  if (job) {
+                    backgroundJobs.push(job);
+                    const bgOp = startOperation("background-ingest", { pid: job.pid, logFile: job.logFile, path: fallbackDest });
+                    bgOp.start();
+                    console.log(`    ${c2.dim}File queued for background processing${c2.reset}`);
+                  } else {
+                    console.log(`    ${c2.dim}File copied to inbox for later processing${c2.reset}`);
+                  }
+                } else {
+                  console.log(`    ${c2.dim}File copied to inbox for later processing${c2.reset}`);
+                }
+              } catch {}
+            }
+          } else {
+            console.log(`  ${c2.yellow}⚠${c2.reset} File not found: ${chatPath}`);
+          }
+        } else if (choiceNum === 2 || choiceNum === 3) {
+          const label = choiceNum === 2 ? "documents" : "notes";
+          const sourcePath = await prompt(`  Path to ${label}`);
+          if (sourcePath) {
+            const resolvedPath = sourcePath.startsWith("~") ? join10(process.env.HOME || "", sourcePath.slice(1)) : sourcePath;
+            if (existsSync9(resolvedPath)) {
+              const spinner = new Spinner(`Scanning ${resolvedPath}...`);
+              spinner.start();
+              const stats = statSync2(resolvedPath);
+              if (stats.isDirectory()) {
+                const { total, byExt } = countFiles(resolvedPath);
+                const extSummary = Object.entries(byExt).sort(([, a], [, b]) => b - a).slice(0, 4).map(([ext, count]) => `${count} .${ext}`).join(", ");
+                spinner.succeed(`Found ${total} files (${extSummary})`);
+                const destDir = join10(inboxDir, basename5(resolvedPath));
+                const copySpinner = new Spinner("Copying to inbox...");
+                copySpinner.start();
+                try {
+                  cpSync(resolvedPath, destDir, { recursive: true });
+                  if (canBackgroundIngest) {
+                    const job = spawnBackground("datacore", ["ingest", destDir], "ingest");
+                    if (job) {
+                      backgroundJobs.push(job);
+                      const bgOp = startOperation("background-ingest", { pid: job.pid, logFile: job.logFile, path: destDir });
+                      bgOp.start();
+                      copySpinner.succeed(`${total} files queued for background processing`);
+                    } else {
+                      copySpinner.succeed(`${total} files copied to inbox`);
+                      console.log(`    ${c2.dim}Process with: datacore ingest ${destDir}${c2.reset}`);
+                    }
+                  } else {
+                    copySpinner.succeed(`${total} files copied to inbox`);
+                    console.log(`    ${c2.dim}Process with /ingest in Claude Code for full knowledge extraction${c2.reset}`);
+                  }
+                  totalImported += total;
+                } catch {
+                  copySpinner.fail("Copy failed");
+                }
+              } else {
+                const singleDest = join10(inboxDir, basename5(resolvedPath));
+                copyFileSync(resolvedPath, singleDest);
+                if (canBackgroundIngest) {
+                  const job = spawnBackground("datacore", ["ingest", singleDest], "ingest");
+                  if (job) {
+                    backgroundJobs.push(job);
+                    const bgOp = startOperation("background-ingest", { pid: job.pid, logFile: job.logFile, path: singleDest });
+                    bgOp.start();
+                    spinner.succeed("File queued for background processing");
+                  } else {
+                    spinner.succeed("File copied to inbox");
+                    console.log(`    ${c2.dim}Process with: datacore ingest ${singleDest}${c2.reset}`);
+                  }
+                } else {
+                  spinner.succeed("File copied to inbox");
+                }
+                totalImported++;
+              }
+            } else {
+              console.log(`  ${c2.yellow}⚠${c2.reset} Path not found: ${sourcePath}`);
+            }
           }
-          creating = await confirm("Create another space?", false);
         }
+        console.log();
+        importing = await confirm("  Import more?", false);
+        if (importing)
+          console.log();
       }
       console.log();
     }
-    if (interactive) {
-      section("Step 6: Install Modules");
-      console.log(`  ${c2.dim}Modules add features like overnight AI processing, CRM, and more.${c2.reset}`);
+    op.completeStep("import_data");
+    op.addStep("verification");
+    op.startStep("verification");
+    const claudeAvailable = commandExists3("claude");
+    if (claudeAvailable && isTTY) {
+      section(`Step 9/${TOTAL_STEPS}: Verification`);
       console.log();
-      const available = getAvailableModules();
-      if (available.length > 0) {
-        const wantModules = await confirm("Would you like to install modules?", true);
-        if (wantModules) {
-          console.log();
-          console.log("  Available modules:");
-          console.log();
-          for (let i = 0;i < available.length; i++) {
-            const mod = available[i];
-            console.log(`  ${c2.cyan}${i + 1}${c2.reset}) ${c2.bold}${mod.name}${c2.reset} - ${mod.description}`);
-            for (const feature of mod.features) {
-              console.log(`     ${c2.dim}• ${feature}${c2.reset}`);
-            }
-            console.log();
-          }
-          const choices = await prompt('Enter numbers to install (comma-separated, or "all", or "none")');
-          let toInstall = [];
-          if (choices.toLowerCase() === "all") {
-            toInstall = available.map((m) => m.name);
-          } else if (choices && choices.toLowerCase() !== "none") {
-            const nums = choices.split(",").map((s) => parseInt(s.trim(), 10));
-            toInstall = nums.filter((n) => n >= 1 && n <= available.length).map((n) => available[n - 1].name);
+      console.log(`  ${c2.dim}Running AI verification to check everything is configured correctly...${c2.reset}`);
+      console.log();
+      const spinner = new Spinner("Claude Code structural integrity check...");
+      spinner.start();
+      try {
+        const agentResult = await invokeAgent({
+          agent: "structural-integrity",
+          params: { mode: "report", scope: "all" }
+        }, { cwd: DATA_DIR8, timeout: 120000 });
+        if (agentResult.success) {
+          spinner.succeed("All checks passed");
+        } else {
+          spinner.fail("Verification completed with issues");
+          if (agentResult.error) {
+            result.warnings.push(`Verification: ${agentResult.error}`);
           }
-          for (const modName of toInstall) {
-            const mod = available.find((m) => m.name === modName);
-            if (!mod)
-              continue;
-            const spinner = new Spinner(`Installing ${modName}...`);
-            spinner.start();
-            try {
-              await sleep(100);
-              installModule(mod.repo);
-              spinner.succeed(`Installed ${modName}`);
-              result.modulesInstalled.push(modName);
-            } catch (err) {
-              spinner.fail(`Failed to install ${modName}: ${err.message}`);
-              result.warnings.push(`Failed to install ${modName}`);
-            }
+        }
+      } catch {
+        spinner.fail("Verification skipped (Claude Code not responding)");
+        result.warnings.push("Could not run verification - run /structural-integrity manually");
+      }
+      const allSpaces = listSpaces();
+      const allInstalledModules = listModules();
+      console.log();
+      console.log(`    ${c2.dim}Spaces:     ${allSpaces.length} (${allSpaces.map((s) => s.name).join(", ")})${c2.reset}`);
+      console.log(`    ${c2.dim}Modules:    ${allInstalledModules.length} installed${c2.reset}`);
+      const inboxOrg = join10(DATA_DIR8, "0-personal", "org", "inbox.org");
+      if (existsSync9(inboxOrg)) {
+        try {
+          const content = readFileSync5(inboxOrg, "utf-8");
+          const todoCount = (content.match(/^\* TODO /gm) || []).length;
+          if (todoCount > 0) {
+            console.log(`    ${c2.dim}GTD:        ${todoCount} inbox items${c2.reset}`);
           }
+        } catch {}
+      }
+      const inboxDir = join10(DATA_DIR8, "0-personal", "0-inbox");
+      if (existsSync9(inboxDir)) {
+        const { total } = countFiles(inboxDir);
+        if (total > 0) {
+          console.log(`    ${c2.dim}Import:     ${total} files in inbox${c2.reset}`);
         }
-      } else {
-        console.log(`  ${c2.dim}No additional modules available to install.${c2.reset}`);
       }
       console.log();
-    }
-    op.addStep("create_claude_symlink");
-    op.startStep("create_claude_symlink");
-    if (isTTY) {
-      section("Step 7: Claude Code Integration");
-      console.log(`  ${c2.dim}Connecting Datacore to Claude Code AI assistant.${c2.reset}`);
+    } else if (isTTY) {
+      section(`Step 9/${TOTAL_STEPS}: Verification`);
       console.log();
-    }
-    const claudeDir = join7(DATA_DIR5, ".claude");
-    if (!existsSync7(claudeDir)) {
-      try {
-        symlinkSync(DATACORE_DIR, claudeDir);
-        result.created.push(claudeDir);
-        if (isTTY)
-          console.log(`  ${c2.green}✓${c2.reset} Created .claude -> .datacore symlink`);
-      } catch {
-        result.warnings.push("Could not create .claude symlink");
-        if (isTTY)
-          console.log(`  ${c2.yellow}○${c2.reset} Could not create symlink`);
-      }
-    } else {
-      if (isTTY)
-        console.log(`  ${c2.green}✓${c2.reset} Found existing .claude/`);
-    }
-    const claudeMd = join7(DATA_DIR5, "CLAUDE.md");
-    const claudeBaseMd = join7(DATA_DIR5, "CLAUDE.base.md");
-    if (!existsSync7(claudeMd) && !existsSync7(claudeBaseMd)) {
-      const allSpaces = listSpaces();
-      writeFileSync4(claudeBaseMd, `# Datacore
-
-AI-powered second brain built on GTD methodology.
-
-## Quick Start
-
-\`\`\`bash
-cd ~/Data && claude
-\`\`\`
-
-## Daily Workflow
-
-1. **Morning**: Run \`/today\` for your daily briefing
-2. **Capture**: Add tasks to \`0-personal/org/inbox.org\`
-3. **Process**: Clear inbox, organize by context
-4. **Work**: Use \`:AI:\` tags to delegate tasks
-5. **Evening**: Run \`/tomorrow\` for wrap-up
-
-## Commands
-
-- \`/today\` - Daily briefing with priorities
-- \`/tomorrow\` - End-of-day wrap-up
-- \`/sync\` - Sync all repos
-- \`datacore doctor\` - Check system health
-
-## Spaces
-
-${allSpaces.map((s) => `- ${s.name}`).join(`
-`) || "- 0-personal"}
-
-## Documentation
-
-See .datacore/specs/ for detailed documentation.
-`);
-      result.created.push(claudeBaseMd);
-      if (isTTY)
-        console.log(`  ${c2.green}✓${c2.reset} Created CLAUDE.base.md`);
-    } else {
-      if (isTTY)
-        console.log(`  ${c2.green}✓${c2.reset} Found existing CLAUDE.md`);
-    }
-    if (isTTY)
+      console.log(`  ${c2.yellow}○${c2.reset} Claude Code not available ${c2.dim}(skipping verification)${c2.reset}`);
+      console.log(`  ${c2.dim}Run /structural-integrity in Claude Code to verify later.${c2.reset}`);
       console.log();
-    op.completeStep("create_claude_symlink");
+    }
+    op.completeStep("verification");
     result.success = true;
     result.nextSteps = [
-      "cd ~/Data && claude",
-      "Add tasks to 0-personal/org/inbox.org",
-      "Run /today for your first daily briefing"
+      `cd ${DATA_DIR8} && claude`,
+      "Run /today for your first daily briefing",
+      "Process inbox with /gtd-daily-start",
+      "Run datacore doctor to check system health"
     ];
     if (isTTY) {
       console.log(INIT_COMPLETE);
       console.log();
-      console.log(`  ${c2.bold}Setup Complete!${c2.reset}`);
+      console.log(`  ${c2.bold}Setup Complete${profile.name ? `, ${profile.name}` : ""}!${c2.reset}`);
       console.log();
-      if (result.spacesCreated.length > 0) {
-        console.log(`  ${c2.green}Spaces created:${c2.reset} ${result.spacesCreated.join(", ")}`);
+      const allSpaces = listSpaces();
+      if (allSpaces.length > 0) {
+        console.log(`  ${c2.green}Your Datacore:${c2.reset}`);
+        for (const s of allSpaces) {
+          const icon = s.type === "personal" ? "\uD83D\uDC64" : "\uD83D\uDC65";
+          console.log(`    ${icon} ${s.name}`);
+        }
+        console.log();
+      }
+      const installedModules = listModules();
+      if (installedModules.length > 0) {
+        console.log(`  ${c2.green}Modules:${c2.reset} ${installedModules.map((m) => m.name).join(", ")}`);
+        console.log();
       }
-      if (result.modulesInstalled.length > 0) {
-        console.log(`  ${c2.green}Modules installed:${c2.reset} ${result.modulesInstalled.join(", ")}`);
+      const envDir = join10(DATACORE_DIR, "env");
+      const envFiles = existsSync9(envDir) ? readdirSync3(envDir).filter((f) => f !== ".gitkeep") : [];
+      if (envFiles.length === 0) {
+        console.log(`  ${c2.bold}API Keys:${c2.reset}`);
+        console.log(`  ${c2.dim}Some modules need API keys to function. Configure them in Claude Code:${c2.reset}`);
+        console.log(`    ${c2.dim}cd ~/Data && claude${c2.reset}`);
+        console.log(`    ${c2.dim}"Help me set up my API keys"${c2.reset}`);
+        console.log(`  ${c2.dim}Keys are stored in .datacore/env/ - gitignored, never leave your machine.${c2.reset}`);
+        console.log();
       }
       if (result.warnings.length > 0) {
         console.log(`  ${c2.yellow}Warnings:${c2.reset} ${result.warnings.length}`);
+        for (const w of result.warnings) {
+          console.log(`    ${c2.dim}• ${w}${c2.reset}`);
+        }
+        console.log();
       }
-      console.log();
       console.log(`  ${c2.bold}Get Started:${c2.reset}`);
       console.log();
       console.log(`  ${c2.cyan}1.${c2.reset} cd ~/Data && claude`);
       console.log(`     ${c2.dim}Start Claude Code in your Datacore directory${c2.reset}`);
       console.log();
       console.log(`  ${c2.cyan}2.${c2.reset} Type ${c2.cyan}/today${c2.reset}`);
-      console.log(`     ${c2.dim}Get your first daily briefing${c2.reset}`);
-      console.log();
-      console.log(`  ${c2.cyan}3.${c2.reset} Add tasks to ${c2.cyan}0-personal/org/inbox.org${c2.reset}`);
-      console.log(`     ${c2.dim}Your GTD capture inbox${c2.reset}`);
+      console.log(`     ${c2.dim}Get your first daily briefing with your imported data${c2.reset}`);
       console.log();
+      const inboxDir = join10(DATA_DIR8, "0-personal", "0-inbox");
+      const inboxFileCount = existsSync9(inboxDir) ? countFiles(inboxDir).total : 0;
+      if (inboxFileCount > 0) {
+        console.log(`  ${c2.cyan}3.${c2.reset} Process your imports`);
+        console.log(`     ${c2.dim}${inboxFileCount} files in inbox - run /ingest in Claude Code${c2.reset}`);
+        console.log();
+      } else {
+        console.log(`  ${c2.cyan}3.${c2.reset} Process your inbox`);
+        console.log(`     ${c2.dim}Add tasks to org/inbox.org - try /gtd-daily-start${c2.reset}`);
+        console.log();
+      }
+      if (backgroundJobs.length > 0) {
+        console.log(`  ${c2.green}Background imports:${c2.reset}`);
+        for (const job of backgroundJobs) {
+          if (verbose) {
+            console.log(`    ${c2.green}✓${c2.reset} ${job.label} processing (PID ${job.pid})`);
+            console.log(`      ${c2.dim}Log: ${job.logFile}${c2.reset}`);
+          } else {
+            console.log(`    ${c2.green}✓${c2.reset} ${job.label} processing`);
+          }
+        }
+        console.log(`    ${c2.dim}Check progress: datacore status${c2.reset}`);
+        console.log();
+      }
+      console.log(`  ${c2.dim}Edit ~/Data/CLAUDE.local.md to teach Claude about you.${c2.reset}`);
       console.log(`  ${c2.dim}Run 'datacore doctor' anytime to check system health.${c2.reset}`);
       console.log();
     }
@@ -9595,233 +11012,8 @@ See .datacore/specs/ for detailed documentation.
   return result;
 }
 
-// src/lib/snapshot.ts
-var import_yaml2 = __toESM(require_dist(), 1);
-import { existsSync as existsSync8, readFileSync as readFileSync4, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5 } from "fs";
-import { execSync as execSync5 } from "child_process";
-import { join as join8 } from "path";
-var DATA_DIR6 = join8(process.env.HOME || "~", "Data");
-var LOCK_FILE = join8(DATA_DIR6, "datacore.lock.yaml");
-var CLI_VERSION = "1.0.6";
-function getGitInfo(path) {
-  if (!existsSync8(join8(path, ".git"))) {
-    return {};
-  }
-  try {
-    const remote = execSync5("git remote get-url origin 2>/dev/null || true", {
-      cwd: path,
-      encoding: "utf-8"
-    }).trim() || undefined;
-    const commit = execSync5("git rev-parse HEAD 2>/dev/null || true", {
-      cwd: path,
-      encoding: "utf-8"
-    }).trim() || undefined;
-    const branch = execSync5("git branch --show-current 2>/dev/null || true", {
-      cwd: path,
-      encoding: "utf-8"
-    }).trim() || undefined;
-    return { remote, commit, branch };
-  } catch {
-    return {};
-  }
-}
-function createSnapshot(options = {}) {
-  const { includeSettings = false } = options;
-  const modules = [];
-  for (const mod of listModules()) {
-    const gitInfo = getGitInfo(mod.path);
-    modules.push({
-      name: mod.name,
-      source: gitInfo.remote || "local",
-      version: mod.version,
-      commit: gitInfo.commit,
-      branch: gitInfo.branch
-    });
-  }
-  const spaces = [];
-  for (const space of listSpaces()) {
-    const gitInfo = getGitInfo(space.path);
-    spaces.push({
-      name: space.name,
-      number: space.number,
-      type: space.type,
-      source: gitInfo.remote,
-      commit: gitInfo.commit
-    });
-  }
-  const deps = checkDependencies();
-  const dependencies = deps.filter((d) => d.installed && d.version).map((d) => ({
-    name: d.name,
-    version: d.version,
-    required: d.required
-  }));
-  const snapshot = {
-    version: "1.0",
-    created: new Date().toISOString(),
-    cliVersion: CLI_VERSION,
-    platform: `${process.platform}-${process.arch}`,
-    modules,
-    spaces,
-    dependencies
-  };
-  if (includeSettings) {
-    const settingsPath = join8(DATA_DIR6, ".datacore", "settings.yaml");
-    if (existsSync8(settingsPath)) {
-      try {
-        const content = readFileSync4(settingsPath, "utf-8");
-        snapshot.settings = import_yaml2.parse(content);
-      } catch {}
-    }
-  }
-  return snapshot;
-}
-function saveSnapshot(snapshot, path) {
-  const lockPath = path || LOCK_FILE;
-  const content = import_yaml2.stringify(snapshot, {
-    lineWidth: 0
-  });
-  writeFileSync5(lockPath, content);
-  return lockPath;
-}
-function loadSnapshot(path) {
-  const lockPath = path || LOCK_FILE;
-  if (!existsSync8(lockPath)) {
-    return null;
-  }
-  try {
-    const content = readFileSync4(lockPath, "utf-8");
-    return import_yaml2.parse(content);
-  } catch {
-    return null;
-  }
-}
-function diffSnapshot(snapshot) {
-  const current = createSnapshot();
-  const diff = {
-    modules: { added: [], removed: [], changed: [] },
-    spaces: { added: [], removed: [] },
-    dependencies: { changed: [] }
-  };
-  const currentModules = new Map(current.modules.map((m) => [m.name, m]));
-  const snapshotModules = new Map(snapshot.modules.map((m) => [m.name, m]));
-  for (const [name, mod] of currentModules) {
-    if (!snapshotModules.has(name)) {
-      diff.modules.added.push(name);
-    } else {
-      const expected = snapshotModules.get(name);
-      if (expected.commit && mod.commit && expected.commit !== mod.commit) {
-        diff.modules.changed.push({
-          name,
-          from: expected.commit.slice(0, 7),
-          to: mod.commit.slice(0, 7)
-        });
-      }
-    }
-  }
-  for (const name of snapshotModules.keys()) {
-    if (!currentModules.has(name)) {
-      diff.modules.removed.push(name);
-    }
-  }
-  const currentSpaces = new Set(current.spaces.map((s) => s.name));
-  const snapshotSpaces = new Set(snapshot.spaces.map((s) => s.name));
-  for (const name of currentSpaces) {
-    if (!snapshotSpaces.has(name)) {
-      diff.spaces.added.push(name);
-    }
-  }
-  for (const name of snapshotSpaces) {
-    if (!currentSpaces.has(name)) {
-      diff.spaces.removed.push(name);
-    }
-  }
-  const currentDeps = new Map(current.dependencies.map((d) => [d.name, d.version]));
-  for (const dep of snapshot.dependencies) {
-    const actualVersion = currentDeps.get(dep.name);
-    if (actualVersion && actualVersion !== dep.version) {
-      diff.dependencies.changed.push({
-        name: dep.name,
-        expected: dep.version,
-        actual: actualVersion
-      });
-    }
-  }
-  return diff;
-}
-function restoreFromSnapshot(snapshot, options = {}) {
-  const { modules = true, spaces = true, dryRun = false } = options;
-  const result = {
-    modulesInstalled: [],
-    modulesFailed: [],
-    spacesCreated: [],
-    warnings: []
-  };
-  if (modules) {
-    const currentModules = new Set(listModules().map((m) => m.name));
-    for (const mod of snapshot.modules) {
-      if (currentModules.has(mod.name)) {
-        continue;
-      }
-      if (mod.source === "local") {
-        result.warnings.push(`Module ${mod.name} was local, cannot restore`);
-        continue;
-      }
-      if (dryRun) {
-        result.modulesInstalled.push(mod.name);
-        continue;
-      }
-      try {
-        const modulesDir = join8(DATA_DIR6, ".datacore", "modules");
-        if (!existsSync8(modulesDir)) {
-          mkdirSync5(modulesDir, { recursive: true });
-        }
-        const modulePath = join8(modulesDir, mod.name);
-        execSync5(`git clone ${mod.source} "${modulePath}"`, { stdio: "pipe" });
-        if (mod.commit) {
-          execSync5(`git checkout ${mod.commit}`, { cwd: modulePath, stdio: "pipe" });
-        } else if (mod.branch) {
-          execSync5(`git checkout ${mod.branch}`, { cwd: modulePath, stdio: "pipe" });
-        }
-        result.modulesInstalled.push(mod.name);
-      } catch (err) {
-        result.modulesFailed.push({
-          name: mod.name,
-          error: err.message
-        });
-      }
-    }
-  }
-  if (spaces) {
-    const currentSpaces = new Set(listSpaces().map((s) => s.name));
-    for (const space of snapshot.spaces) {
-      if (currentSpaces.has(space.name)) {
-        continue;
-      }
-      if (dryRun) {
-        result.spacesCreated.push(space.name);
-        continue;
-      }
-      if (space.source) {
-        try {
-          const spacePath = join8(DATA_DIR6, space.name);
-          execSync5(`git clone ${space.source} "${spacePath}"`, { stdio: "pipe" });
-          if (space.commit) {
-            execSync5(`git checkout ${space.commit}`, { cwd: spacePath, stdio: "pipe" });
-          }
-          result.spacesCreated.push(space.name);
-        } catch (err) {
-          result.warnings.push(`Could not clone space ${space.name}: ${err.message}`);
-        }
-      } else {
-        result.warnings.push(`Space ${space.name} has no git source, skipping`);
-      }
-    }
-  }
-  return result;
-}
-
 // src/index.ts
-var VERSION = "1.0.6";
+var VERSION = "1.0.7";
 var args = process.argv.slice(2);
 var parsed = parseArgs(args);
 async function handleMeta(command, cmdArgs, flags, format) {
@@ -9832,17 +11024,21 @@ async function handleMeta(command, cmdArgs, flags, format) {
     case "init": {
       if (isInitialized() && !flags.force) {
         if (format === "json") {
-          output({ success: true, message: "Datacore already initialized" }, format);
+          output({ success: true, message: "Datacore already initialized", hint: "Use --force to re-initialize or run datacore doctor" }, format);
         } else {
-          info("Datacore already initialized");
-          info("Use --force to re-initialize");
+          info("Datacore already initialized at ~/Data");
+          info("Run datacore doctor to check health");
+          info("Run datacore module list to see modules");
+          info("Use --force to re-run the setup wizard");
         }
         break;
       }
       const result = await initDatacore({
         nonInteractive: flags.yes === true,
         skipChecks: flags["skip-checks"] === true,
-        stream: format === "human"
+        stream: format === "human",
+        verbose: flags.verbose === true,
+        force: flags.force === true
       });
       if (format === "json") {
         output(result, format);
@@ -9895,7 +11091,7 @@ async function handleMeta(command, cmdArgs, flags, format) {
         for (const dep of result.dependencies) {
           const status = dep.installed ? "✓" : "✗";
           const version = dep.version ? ` (${dep.version})` : "";
-          const required = dep.required ? "" : " (optional)";
+          const required = dep.required ? "" : " (recommended)";
           console.log(`  ${status} ${dep.name}${version}${required}`);
           if (!dep.installed && dep.installCommand) {
             console.log(`      Install: ${dep.installCommand}`);
@@ -10252,8 +11448,8 @@ async function handleResource(resource, action, cmdArgs, flags, format) {
             throw new CLIError("ERR_INVALID_ARGUMENT", "Missing task description", 'Usage: datacore nightshift queue "Research topic X"');
           }
           const { existsSync: existsSync10, appendFileSync } = await import("fs");
-          const { join: join10 } = await import("path");
-          const inboxPath = join10(process.env.HOME || "~", "Data", "0-personal", "org", "inbox.org");
+          const { join: join11 } = await import("path");
+          const inboxPath = join11(process.env.HOME || "~", "Data", "0-personal", "org", "inbox.org");
           if (!existsSync10(inboxPath)) {
             throw new CLIError("ERR_NOT_FOUND", "inbox.org not found. Run datacore init first.");
           }
@@ -10277,13 +11473,13 @@ async function handleResource(resource, action, cmdArgs, flags, format) {
       break;
     }
     case "cron": {
-      const { execSync: execSync6, exec: execAsync } = await import("child_process");
+      const { execSync: execSync5, exec: execAsync } = await import("child_process");
       switch (action) {
         case "install": {
           info("Installing cron jobs...");
           let currentCron = "";
           try {
-            currentCron = execSync6("crontab -l 2>/dev/null", { encoding: "utf-8" });
+            currentCron = execSync5("crontab -l 2>/dev/null", { encoding: "utf-8" });
           } catch {}
           if (currentCron.includes("# Datacore")) {
             if (!flags.force) {
@@ -10306,7 +11502,7 @@ async function handleResource(resource, action, cmdArgs, flags, format) {
 `;
           const newCron = currentCron.trim() + `
 ` + datacoreCron;
-          execSync6(`echo "${newCron}" | crontab -`, { stdio: "pipe" });
+          execSync5(`echo "${newCron}" | crontab -`, { stdio: "pipe" });
           success("Cron jobs installed");
           info("  8:00 AM weekdays - Daily briefing");
           info("  6:00 PM weekdays - Evening wrap-up");
@@ -10316,7 +11512,7 @@ async function handleResource(resource, action, cmdArgs, flags, format) {
         case "status": {
           let crontab = "";
           try {
-            crontab = execSync6("crontab -l 2>/dev/null", { encoding: "utf-8" });
+            crontab = execSync5("crontab -l 2>/dev/null", { encoding: "utf-8" });
           } catch {}
           const datacoreJobs = crontab.split(`
 `).filter((line) => line.includes("datacore") && !line.startsWith("#"));
@@ -10339,7 +11535,7 @@ async function handleResource(resource, action, cmdArgs, flags, format) {
           info("Removing cron jobs...");
           let currentCron = "";
           try {
-            currentCron = execSync6("crontab -l 2>/dev/null", { encoding: "utf-8" });
+            currentCron = execSync5("crontab -l 2>/dev/null", { encoding: "utf-8" });
           } catch {
             info("No cron jobs to remove");
             break;
@@ -10348,9 +11544,9 @@ async function handleResource(resource, action, cmdArgs, flags, format) {
 `).filter((line) => !line.includes("# Datacore") && !line.includes("datacore")).join(`
 `).trim();
           if (newCron) {
-            execSync6(`echo "${newCron}" | crontab -`, { stdio: "pipe" });
+            execSync5(`echo "${newCron}" | crontab -`, { stdio: "pipe" });
           } else {
-            execSync6("crontab -r", { stdio: "pipe" });
+            execSync5("crontab -r", { stdio: "pipe" });
           }
           success("Cron jobs removed");
           break;