@piut/cli 3.5.0 → 3.6.0

package/dist/cli.js

@@ -24,7 +24,19 @@ async function validateKey(key) {
   }
   return res.json();
 }
-async function* buildBrainStreaming(key, input2) {
+async function loginWithEmail(email, password3) {
+  const res = await fetch(`${API_BASE}/api/cli/login`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ email, password: password3 })
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(body.error || `Login failed (HTTP ${res.status})`);
+  }
+  return res.json();
+}
+async function* buildBrainStreaming(key, input3) {
   const res = await fetch(`${API_BASE}/api/cli/build-brain`, {
     method: "POST",
     headers: {
@@ -32,7 +44,7 @@ async function* buildBrainStreaming(key, input2) {
       "Content-Type": "application/json",
       Accept: "text/event-stream"
     },
-    body: JSON.stringify(input2)
+    body: JSON.stringify(input3)
   });
   if (!res.ok) {
     const body = await res.json().catch(() => ({ error: "Unknown error" }));
@@ -184,6 +196,47 @@ async function unregisterProject(key, projectPath, machineId) {
     throw new Error(body.error || `Unregister project failed (HTTP ${res.status})`);
   }
 }
+async function deleteConnections(key, toolNames) {
+  try {
+    await fetch(`${API_BASE}/api/mcp/connections`, {
+      method: "DELETE",
+      headers: {
+        Authorization: `Bearer ${key}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ toolNames })
+    });
+  } catch {
+  }
+}
+async function resyncBrain(serverUrl, key, content) {
+  const res = await fetch(serverUrl, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${key}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "tools/call",
+      params: {
+        name: "update_brain",
+        arguments: { content }
+      }
+    })
+  });
+  if (!res.ok) {
+    throw new Error(`Resync failed (HTTP ${res.status})`);
+  }
+  const data = await res.json();
+  if (data.error) {
+    throw new Error(data.error.message || "Resync failed");
+  }
+  const resultContent = data.result?.content;
+  const text = Array.isArray(resultContent) && resultContent[0]?.text ? resultContent[0].text : "Brain updated";
+  return { summary: text };
+}
 async function unpublishServer(key) {
   const res = await fetch(`${API_BASE}/api/mcp/publish`, {
     method: "POST",
@@ -614,18 +667,35 @@ var Spinner = class {
   startTime = Date.now();
   message = "";
   sections = [];
+  currentSection = null;
   start(message) {
     this.message = message;
     this.startTime = Date.now();
     this.sections = [];
+    this.currentSection = null;
     this.render();
     this.interval = setInterval(() => this.render(), 80);
   }
   addSection(name) {
-    this.clearLine();
-    const elapsed = this.elapsed();
-    console.log(`  ${success("\u2713")} ${name.padEnd(12)} ${dim(elapsed)}`);
+    if (this.currentSection) {
+      this.clearLine();
+      const elapsed = this.elapsed();
+      const label = this.capitalize(this.currentSection);
+      console.log(`  ${success("\u2713")} ${label.padEnd(14)} ${dim(elapsed)}`);
+    }
+    this.currentSection = name;
     this.sections.push(name);
+    this.message = `Building ${this.capitalize(name)}...`;
+  }
+  completeAll() {
+    if (this.currentSection) {
+      this.clearLine();
+      const elapsed = this.elapsed();
+      const label = this.capitalize(this.currentSection);
+      console.log(`  ${success("\u2713")} ${label.padEnd(14)} ${dim(elapsed)}`);
+      this.currentSection = null;
+    }
+    this.message = "Finalizing...";
   }
   updateMessage(message) {
     this.message = message;
@@ -655,6 +725,9 @@ var Spinner = class {
   clearLine() {
     process.stdout.write("\r\x1B[K");
   }
+  capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+  }
 };
 
 // src/types.ts
@@ -902,15 +975,459 @@ function isCommandAvailable(cmd) {
 }
 
 // src/commands/status.ts
-import fs7 from "fs";
-import path9 from "path";
+import fs9 from "fs";
+import path12 from "path";
 import chalk3 from "chalk";
 
 // src/lib/brain-scanner.ts
-import fs5 from "fs";
+import fs7 from "fs";
+import path10 from "path";
+import os5 from "os";
+
+// src/lib/file-types.ts
 import path7 from "path";
+var DOCUMENT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".pdf",
+  ".docx",
+  ".doc",
+  ".pptx",
+  ".pages",
+  ".key",
+  ".rtf",
+  ".odt",
+  ".odp",
+  ".eml",
+  ".mbox"
+]);
+var PLAIN_TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".md",
+  ".markdown",
+  ".txt",
+  ".csv",
+  ".xml",
+  ".html",
+  ".htm",
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".rst",
+  ".adoc",
+  ".tex",
+  ".ini",
+  ".cfg",
+  ".conf",
+  ".log"
+]);
+var AI_CONFIG_FILENAMES = /* @__PURE__ */ new Set([
+  "CLAUDE.md",
+  ".cursorrules",
+  ".windsurfrules",
+  ".rules",
+  ".clinerules",
+  "AGENTS.md",
+  "CONVENTIONS.md",
+  "MEMORY.md",
+  "SOUL.md",
+  "IDENTITY.md",
+  "copilot-instructions.md"
+]);
+var PARSEABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ...DOCUMENT_EXTENSIONS,
+  ...PLAIN_TEXT_EXTENSIONS
+]);
+var EXCLUDED_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".js",
+  ".ts",
+  ".jsx",
+  ".tsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".pyw",
+  ".pyi",
+  ".rs",
+  ".go",
+  ".java",
+  ".kt",
+  ".scala",
+  ".clj",
+  ".c",
+  ".cpp",
+  ".cc",
+  ".h",
+  ".hpp",
+  ".cs",
+  ".rb",
+  ".php",
+  ".swift",
+  ".m",
+  ".mm",
+  ".lua",
+  ".r",
+  ".jl",
+  ".zig",
+  ".nim",
+  ".v",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".fish",
+  ".ps1",
+  ".bat",
+  ".cmd",
+  ".sql",
+  ".graphql",
+  ".gql",
+  ".proto",
+  ".css",
+  ".scss",
+  ".sass",
+  ".less",
+  ".styl",
+  ".xls",
+  ".xlsx",
+  ".numbers",
+  ".sqlite",
+  ".db",
+  ".dat",
+  ".parquet",
+  ".avro",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".svg",
+  ".ico",
+  ".webp",
+  ".bmp",
+  ".tiff",
+  ".heic",
+  ".mp3",
+  ".mp4",
+  ".wav",
+  ".aac",
+  ".flac",
+  ".ogg",
+  ".avi",
+  ".mov",
+  ".mkv",
+  ".wmv",
+  ".webm",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".bz2",
+  ".xz",
+  ".7z",
+  ".rar",
+  ".dmg",
+  ".iso",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".o",
+  ".a",
+  ".wasm",
+  ".class",
+  ".jar",
+  ".pyc",
+  ".pyo",
+  ".ttf",
+  ".otf",
+  ".woff",
+  ".woff2",
+  ".eot",
+  ".lock",
+  ".map",
+  ".min.js",
+  ".min.css"
+]);
+function canParse(filename) {
+  return PARSEABLE_EXTENSIONS.has(path7.extname(filename).toLowerCase());
+}
+function isAiConfigFile(filename) {
+  return AI_CONFIG_FILENAMES.has(path7.basename(filename));
+}
+function getFileCategory(filename) {
+  const base = path7.basename(filename);
+  if (AI_CONFIG_FILENAMES.has(base)) return "config";
+  const ext = path7.extname(filename).toLowerCase();
+  if (DOCUMENT_EXTENSIONS.has(ext)) return "document";
+  if (PLAIN_TEXT_EXTENSIONS.has(ext)) return "text";
+  if (EXCLUDED_EXTENSIONS.has(ext)) return "excluded";
+  return "unknown";
+}
+
+// src/lib/file-parsers.ts
+import fs5 from "fs";
+import path8 from "path";
+var MAX_RAW_SIZE = 500 * 1024;
+var MAX_EXTRACTED_TEXT = 100 * 1024;
+function truncate(text) {
+  if (text.length <= MAX_EXTRACTED_TEXT) return text;
+  return text.slice(0, MAX_EXTRACTED_TEXT);
+}
+function stripHtml(html) {
+  return html.replace(/<br\s*\/?>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<\/div>/gi, "\n").replace(/<\/li>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+}
+async function parsePdf(buffer) {
+  const { PDFParse } = await import("pdf-parse");
+  const parser = new PDFParse({ data: new Uint8Array(buffer) });
+  const result = await parser.getText();
+  return result.text;
+}
+async function parseDocx(buffer) {
+  const { extractRawText } = await import("mammoth");
+  const result = await extractRawText({ buffer });
+  return result.value;
+}
+async function parsePptx(buffer) {
+  const JSZip = (await import("jszip")).default;
+  const zip = await JSZip.loadAsync(buffer);
+  const texts = [];
+  const slideFiles = Object.keys(zip.files).filter((name) => /^ppt\/slides\/slide\d+\.xml$/i.test(name)).sort((a, b) => {
+    const numA = parseInt(a.match(/slide(\d+)/)?.[1] || "0");
+    const numB = parseInt(b.match(/slide(\d+)/)?.[1] || "0");
+    return numA - numB;
+  });
+  for (const slidePath of slideFiles) {
+    const xml = await zip.files[slidePath].async("string");
+    const matches = xml.match(/<a:t[^>]*>([^<]*)<\/a:t>/g);
+    if (matches) {
+      texts.push(matches.map((m) => m.replace(/<[^>]+>/g, "")).join(" "));
+    }
+  }
+  return texts.join("\n\n");
+}
+async function parseAppleDoc(buffer) {
+  const JSZip = (await import("jszip")).default;
+  const zip = await JSZip.loadAsync(buffer);
+  if (zip.files["preview.pdf"]) {
+    const pdfBuf = await zip.files["preview.pdf"].async("nodebuffer");
+    try {
+      return await parsePdf(pdfBuf);
+    } catch {
+    }
+  }
+  const texts = [];
+  for (const [name, file] of Object.entries(zip.files)) {
+    if (name.endsWith(".iwa") && !file.dir) {
+      try {
+        const buf = await file.async("nodebuffer");
+        const str = buf.toString("utf-8");
+        const readable = str.match(/[\x20-\x7E\xC0-\xFF]{4,}/g);
+        if (readable) {
+          texts.push(...readable.filter((s) => s.length > 10));
+        }
+      } catch {
+      }
+    }
+  }
+  return texts.join("\n\n");
+}
+async function parseRtf(buffer) {
+  const { fromString } = await import("@iarna/rtf-to-html");
+  return new Promise((resolve, reject) => {
+    fromString(buffer.toString("utf-8"), (err, html) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve(stripHtml(html));
+    });
+  });
+}
+async function parseOpenDocument(buffer) {
+  const JSZip = (await import("jszip")).default;
+  const zip = await JSZip.loadAsync(buffer);
+  const contentXml = zip.files["content.xml"];
+  if (!contentXml) return "";
+  return stripHtml(await contentXml.async("string"));
+}
+function parseEml(buffer) {
+  const content = buffer.toString("utf-8");
+  const boundaryMatch = content.match(/boundary="?([^\s"]+)"?/i);
+  if (boundaryMatch) {
+    const parts = content.split(`--${boundaryMatch[1]}`);
+    for (const part of parts) {
+      if (/content-type:\s*text\/plain/i.test(part)) {
+        const bodyStart = part.indexOf("\n\n");
+        if (bodyStart !== -1) return part.slice(bodyStart + 2).trim();
+      }
+    }
+  }
+  const headerEnd = content.indexOf("\n\n");
+  if (headerEnd !== -1) {
+    const body = content.slice(headerEnd + 2);
+    if (!/<html/i.test(body.slice(0, 200))) return body.trim();
+    return stripHtml(body);
+  }
+  return content.trim();
+}
+function parseMbox(buffer) {
+  const content = buffer.toString("utf-8");
+  const messages = content.split(/^From /m).filter(Boolean);
+  const texts = [];
+  for (const msg of messages.slice(0, 50)) {
+    const headerEnd = msg.indexOf("\n\n");
+    if (headerEnd !== -1) {
+      const body = msg.slice(headerEnd + 2);
+      texts.push(!/<html/i.test(body.slice(0, 200)) ? body.trim() : stripHtml(body));
+    }
+  }
+  return texts.join("\n\n---\n\n");
+}
+async function extractTextFromFile(filePath) {
+  const ext = path8.extname(filePath).toLowerCase();
+  try {
+    const stat = fs5.statSync(filePath);
+    if (!stat.isFile()) return null;
+    if (stat.size > MAX_RAW_SIZE) return null;
+  } catch {
+    return null;
+  }
+  if (PLAIN_TEXT_EXTENSIONS.has(ext)) {
+    try {
+      return truncate(fs5.readFileSync(filePath, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  if (!DOCUMENT_EXTENSIONS.has(ext)) return null;
+  try {
+    const buffer = fs5.readFileSync(filePath);
+    let text;
+    switch (ext) {
+      case ".pdf":
+        text = await parsePdf(buffer);
+        break;
+      case ".docx":
+      case ".doc":
+        text = await parseDocx(buffer);
+        break;
+      case ".pptx":
+        text = await parsePptx(buffer);
+        break;
+      case ".pages":
+      case ".key":
+        text = await parseAppleDoc(buffer);
+        break;
+      case ".rtf":
+        text = await parseRtf(buffer);
+        break;
+      case ".odt":
+      case ".odp":
+        text = await parseOpenDocument(buffer);
+        break;
+      case ".eml":
+        text = parseEml(buffer);
+        break;
+      case ".mbox":
+        text = parseMbox(buffer);
+        break;
+      default:
+        return null;
+    }
+    return truncate(text);
+  } catch {
+    return null;
+  }
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+// src/lib/folder-tree.ts
+import fs6 from "fs";
+import path9 from "path";
 import os4 from "os";
 var home = os4.homedir();
+function displayPath(p) {
+  return p.startsWith(home) ? "~" + p.slice(home.length) : p;
+}
+function groupFilesByFolder(files) {
+  const map = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const folder = file.folder;
+    if (!map.has(folder)) map.set(folder, []);
+    map.get(folder).push(file);
+  }
+  const results = [];
+  for (const [folderPath, folderFiles] of map) {
+    results.push({
+      path: folderPath,
+      displayPath: displayPath(folderPath),
+      files: folderFiles,
+      fileCount: folderFiles.length,
+      totalBytes: folderFiles.reduce((sum, f) => sum + f.sizeBytes, 0)
+    });
+  }
+  results.sort((a, b) => a.displayPath.localeCompare(b.displayPath));
+  return results;
+}
+function formatFolderChoice(folder) {
+  return `${folder.displayPath} \u2014 ${folder.fileCount} file${folder.fileCount === 1 ? "" : "s"} (${formatSize(folder.totalBytes)})`;
+}
+function formatSelectionSummary(folders) {
+  const totalFiles = folders.reduce((sum, f) => sum + f.fileCount, 0);
+  const totalBytes = folders.reduce((sum, f) => sum + f.totalBytes, 0);
+  return `${folders.length} folder${folders.length === 1 ? "" : "s"} selected (${totalFiles} file${totalFiles === 1 ? "" : "s"}, ${formatSize(totalBytes)})`;
+}
+var SKIP_HOME_DIRS = /* @__PURE__ */ new Set([
+  "Library",
+  "Applications",
+  "Public",
+  "Movies",
+  "Music",
+  "Pictures",
+  "Templates",
+  ".Trash"
+]);
+var INCLUDE_DOT_DIRS = /* @__PURE__ */ new Set([
+  ".claude",
+  ".cursor",
+  ".windsurf",
+  ".openclaw",
+  ".zed",
+  ".github",
+  ".amazonq"
+]);
+function getDefaultScanDirs() {
+  const dirs = [];
+  try {
+    const entries = fs6.readdirSync(home, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith(".") && !INCLUDE_DOT_DIRS.has(entry.name)) continue;
+      if (SKIP_HOME_DIRS.has(entry.name)) continue;
+      dirs.push(path9.join(home, entry.name));
+    }
+  } catch {
+  }
+  const cloudStorage = path9.join(home, "Library", "CloudStorage");
+  try {
+    if (fs6.existsSync(cloudStorage) && fs6.statSync(cloudStorage).isDirectory()) {
+      const entries = fs6.readdirSync(cloudStorage, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const fullPath = path9.join(cloudStorage, entry.name);
+        if (!dirs.includes(fullPath)) {
+          dirs.push(fullPath);
+        }
+      }
+    }
+  } catch {
+  }
+  if (dirs.length === 0) dirs.push(home);
+  return dirs;
+}
+
+// src/lib/brain-scanner.ts
+var home2 = os5.homedir();
 var SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -932,21 +1449,6 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
   "Cache",
   ".piut"
 ]);
-var FULL_READ_FILES = /* @__PURE__ */ new Set([
-  "README.md",
-  "CLAUDE.md",
-  ".cursorrules",
-  ".windsurfrules",
-  ".rules",
-  ".clinerules",
-  "AGENTS.md",
-  "CONVENTIONS.md",
-  "MEMORY.md",
-  "SOUL.md",
-  "IDENTITY.md"
-]);
-var MAX_FILE_SIZE = 100 * 1024;
-var RECENT_DAYS = 30;
 var SCAN_DOT_DIRS = /* @__PURE__ */ new Set([
   ".claude",
   ".cursor",
@@ -957,54 +1459,26 @@ var SCAN_DOT_DIRS = /* @__PURE__ */ new Set([
   ".vscode"
 ]);
 function shouldSkipDir(name) {
-  if (name.startsWith(".") && !SCAN_DOT_DIRS.has(name)) {
-    return true;
-  }
+  if (name.startsWith(".") && !SCAN_DOT_DIRS.has(name)) return true;
   return SKIP_DIRS.has(name);
 }
-function readFileSafe(filePath) {
-  try {
-    const stat = fs5.statSync(filePath);
-    if (stat.size > MAX_FILE_SIZE) return null;
-    if (!stat.isFile()) return null;
-    return fs5.readFileSync(filePath, "utf-8");
-  } catch {
-    return null;
-  }
-}
-function getFolderTree(dir, depth = 0, maxDepth = 3) {
-  if (depth >= maxDepth) return [];
-  const entries = [];
-  try {
-    const items = fs5.readdirSync(dir, { withFileTypes: true });
-    for (const item of items) {
-      if (!item.isDirectory()) continue;
-      if (shouldSkipDir(item.name)) continue;
-      const indent = "  ".repeat(depth);
-      entries.push(`${indent}${item.name}/`);
-      entries.push(...getFolderTree(path7.join(dir, item.name), depth + 1, maxDepth));
-    }
-  } catch {
-  }
-  return entries;
-}
 function isProject(dirPath) {
-  return fs5.existsSync(path7.join(dirPath, ".git")) || fs5.existsSync(path7.join(dirPath, "package.json")) || fs5.existsSync(path7.join(dirPath, "Cargo.toml")) || fs5.existsSync(path7.join(dirPath, "pyproject.toml")) || fs5.existsSync(path7.join(dirPath, "go.mod"));
+  return fs7.existsSync(path10.join(dirPath, ".git")) || fs7.existsSync(path10.join(dirPath, "package.json")) || fs7.existsSync(path10.join(dirPath, "Cargo.toml")) || fs7.existsSync(path10.join(dirPath, "pyproject.toml")) || fs7.existsSync(path10.join(dirPath, "go.mod"));
 }
 function buildProjectInfo(projectPath) {
-  const hasPkgJson = fs5.existsSync(path7.join(projectPath, "package.json"));
+  const hasPkgJson = fs7.existsSync(path10.join(projectPath, "package.json"));
   let description = "";
   if (hasPkgJson) {
     try {
-      const pkg = JSON.parse(fs5.readFileSync(path7.join(projectPath, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs7.readFileSync(path10.join(projectPath, "package.json"), "utf-8"));
       description = pkg.description || "";
     } catch {
     }
   }
-  const readmePath = path7.join(projectPath, "README.md");
-  if (!description && fs5.existsSync(readmePath)) {
-    const content = readFileSafe(readmePath);
-    if (content) {
+  const readmePath = path10.join(projectPath, "README.md");
+  if (!description && fs7.existsSync(readmePath)) {
+    try {
+      const content = fs7.readFileSync(readmePath, "utf-8");
       const lines = content.split("\n");
       let foundHeading = false;
       for (const line of lines) {
@@ -1017,18 +1491,19 @@ function buildProjectInfo(projectPath) {
           break;
         }
       }
+    } catch {
     }
   }
   return {
-    name: path7.basename(projectPath),
+    name: path10.basename(projectPath),
     path: projectPath,
     description,
-    hasClaudeMd: fs5.existsSync(path7.join(projectPath, "CLAUDE.md")) || fs5.existsSync(path7.join(projectPath, ".claude", "rules")),
-    hasCursorRules: fs5.existsSync(path7.join(projectPath, ".cursorrules")) || fs5.existsSync(path7.join(projectPath, ".cursor", "rules")),
-    hasWindsurfRules: fs5.existsSync(path7.join(projectPath, ".windsurfrules")) || fs5.existsSync(path7.join(projectPath, ".windsurf", "rules")),
-    hasCopilotInstructions: fs5.existsSync(path7.join(projectPath, ".github", "copilot-instructions.md")) || fs5.existsSync(path7.join(projectPath, ".github", "instructions")),
-    hasConventionsMd: fs5.existsSync(path7.join(projectPath, "CONVENTIONS.md")) || fs5.existsSync(path7.join(projectPath, ".amazonq", "rules")),
-    hasZedRules: fs5.existsSync(path7.join(projectPath, ".rules"))
+    hasClaudeMd: fs7.existsSync(path10.join(projectPath, "CLAUDE.md")) || fs7.existsSync(path10.join(projectPath, ".claude", "rules")),
+    hasCursorRules: fs7.existsSync(path10.join(projectPath, ".cursorrules")) || fs7.existsSync(path10.join(projectPath, ".cursor", "rules")),
+    hasWindsurfRules: fs7.existsSync(path10.join(projectPath, ".windsurfrules")) || fs7.existsSync(path10.join(projectPath, ".windsurf", "rules")),
+    hasCopilotInstructions: fs7.existsSync(path10.join(projectPath, ".github", "copilot-instructions.md")) || fs7.existsSync(path10.join(projectPath, ".github", "instructions")),
+    hasConventionsMd: fs7.existsSync(path10.join(projectPath, "CONVENTIONS.md")) || fs7.existsSync(path10.join(projectPath, ".amazonq", "rules")),
+    hasZedRules: fs7.existsSync(path10.join(projectPath, ".rules"))
   };
 }
 var MAX_PROJECT_DEPTH = 4;
@@ -1038,17 +1513,17 @@ function detectProjects(scanDirs, onProgress) {
   function walk(dir, depth) {
     if (depth > MAX_PROJECT_DEPTH) return;
     try {
-      const items = fs5.readdirSync(dir, { withFileTypes: true });
+      const items = fs7.readdirSync(dir, { withFileTypes: true });
       for (const item of items) {
         if (!item.isDirectory()) continue;
         if (shouldSkipDir(item.name)) continue;
-        const fullPath = path7.join(dir, item.name);
+        const fullPath = path10.join(dir, item.name);
         if (seen.has(fullPath)) continue;
         seen.add(fullPath);
         if (isProject(fullPath)) {
           const info = buildProjectInfo(fullPath);
           projects.push(info);
-          onProgress?.({ phase: "projects", message: `${info.name} (${fullPath.replace(home, "~")})` });
+          onProgress?.({ phase: "projects", message: `${info.name} (${fullPath.replace(home2, "~")})` });
         } else {
           walk(fullPath, depth + 1);
         }
@@ -1061,150 +1536,148 @@ function detectProjects(scanDirs, onProgress) {
   }
   return projects;
 }
+var MAX_CONFIG_SIZE = 100 * 1024;
 function collectConfigFiles(projects, onProgress) {
   const configs = [];
   const globalPaths = [
-    path7.join(home, ".claude", "MEMORY.md"),
-    path7.join(home, ".claude", "CLAUDE.md"),
-    path7.join(home, ".openclaw", "workspace", "SOUL.md"),
-    path7.join(home, ".openclaw", "workspace", "MEMORY.md")
+    path10.join(home2, ".claude", "MEMORY.md"),
+    path10.join(home2, ".claude", "CLAUDE.md"),
+    path10.join(home2, ".openclaw", "workspace", "SOUL.md"),
+    path10.join(home2, ".openclaw", "workspace", "MEMORY.md")
   ];
   for (const gp of globalPaths) {
-    const content = readFileSafe(gp);
-    if (content && content.trim()) {
-      const name = `~/${path7.relative(home, gp)}`;
-      configs.push({ name, content });
-      onProgress?.({ phase: "configs", message: name });
-    }
-  }
-  for (const project of projects) {
-    for (const fileName of FULL_READ_FILES) {
-      const filePath = path7.join(project.path, fileName);
-      const content = readFileSafe(filePath);
-      if (content && content.trim()) {
-        const name = `${project.name}/${fileName}`;
+    try {
+      const stat = fs7.statSync(gp);
+      if (!stat.isFile() || stat.size > MAX_CONFIG_SIZE) continue;
+      const content = fs7.readFileSync(gp, "utf-8");
+      if (content.trim()) {
+        const name = `~/${path10.relative(home2, gp)}`;
         configs.push({ name, content });
         onProgress?.({ phase: "configs", message: name });
       }
+    } catch {
     }
-    const pkgPath = path7.join(project.path, "package.json");
-    const pkgContent = readFileSafe(pkgPath);
-    if (pkgContent) {
+  }
+  for (const project of projects) {
+    for (const fileName of AI_CONFIG_FILENAMES) {
+      const filePath = path10.join(project.path, fileName);
       try {
-        const pkg = JSON.parse(pkgContent);
-        const summary = JSON.stringify({ name: pkg.name, description: pkg.description }, null, 2);
-        const name = `${project.name}/package.json`;
-        configs.push({ name, content: summary });
-        onProgress?.({ phase: "configs", message: name });
+        const stat = fs7.statSync(filePath);
+        if (!stat.isFile() || stat.size > MAX_CONFIG_SIZE) continue;
+        const content = fs7.readFileSync(filePath, "utf-8");
+        if (content.trim()) {
+          const name = `${project.name}/${fileName}`;
+          configs.push({ name, content });
+          onProgress?.({ phase: "configs", message: name });
+        }
       } catch {
       }
     }
+    const pkgPath = path10.join(project.path, "package.json");
+    try {
+      const stat = fs7.statSync(pkgPath);
+      if (stat.isFile() && stat.size <= MAX_CONFIG_SIZE) {
+        const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+        const summary = JSON.stringify({ name: pkg.name, description: pkg.description }, null, 2);
+        configs.push({ name: `${project.name}/package.json`, content: summary });
+        onProgress?.({ phase: "configs", message: `${project.name}/package.json` });
+      }
+    } catch {
+    }
   }
   return configs;
 }
-function collectRecentDocs(projects, onProgress) {
-  const docs = [];
-  const cutoff = Date.now() - RECENT_DAYS * 24 * 60 * 60 * 1e3;
+var MAX_SCAN_DEPTH = 6;
+var MAX_FILES = 500;
+async function scanFilesInDirs(dirs, onProgress) {
+  const files = [];
   const seen = /* @__PURE__ */ new Set();
-  for (const project of projects) {
+  function walk(dir, depth) {
+    if (depth > MAX_SCAN_DEPTH) return [];
+    const found = [];
     try {
-      const items = fs5.readdirSync(project.path, { withFileTypes: true });
+      const items = fs7.readdirSync(dir, { withFileTypes: true });
       for (const item of items) {
-        if (!item.isFile()) continue;
-        if (!item.name.endsWith(".md")) continue;
-        if (FULL_READ_FILES.has(item.name)) continue;
-        if (item.name.startsWith(".")) continue;
-        const filePath = path7.join(project.path, item.name);
-        if (seen.has(filePath)) continue;
-        seen.add(filePath);
-        try {
-          const stat = fs5.statSync(filePath);
-          if (stat.mtimeMs < cutoff) continue;
-          if (stat.size > MAX_FILE_SIZE) continue;
-          const content = fs5.readFileSync(filePath, "utf-8");
-          if (content.trim()) {
-            const name = `${project.name}/${item.name}`;
-            docs.push({ name, content });
-            onProgress?.({ phase: "docs", message: name });
+        if (item.isDirectory()) {
+          if (!shouldSkipDir(item.name)) {
+            found.push(...walk(path10.join(dir, item.name), depth + 1));
+          }
+        } else if (item.isFile()) {
+          if (canParse(item.name) && !isAiConfigFile(item.name)) {
+            const fullPath = path10.join(dir, item.name);
+            if (!seen.has(fullPath)) {
+              seen.add(fullPath);
+              found.push(fullPath);
+            }
           }
-        } catch {
         }
       }
     } catch {
     }
+    return found;
   }
-  return docs.slice(0, 20);
-}
-var SKIP_HOME_DIRS = /* @__PURE__ */ new Set([
-  "Library",
-  "Applications",
-  "Public",
-  "Movies",
-  "Music",
-  "Pictures",
-  "Templates",
-  ".Trash"
-]);
-var INCLUDE_DOT_DIRS = /* @__PURE__ */ new Set([
-  ".claude",
-  ".cursor",
-  ".windsurf",
-  ".openclaw",
-  ".zed",
-  ".github",
-  ".amazonq"
-]);
-function getDefaultScanDirs() {
-  const dirs = [];
-  try {
-    const entries = fs5.readdirSync(home, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      if (entry.name.startsWith(".") && !INCLUDE_DOT_DIRS.has(entry.name)) continue;
-      if (SKIP_HOME_DIRS.has(entry.name)) continue;
-      dirs.push(path7.join(home, entry.name));
-    }
-  } catch {
+  const allPaths = [];
+  for (const dir of dirs) {
+    onProgress?.({ phase: "scanning", message: displayPath(dir) });
+    allPaths.push(...walk(dir, 0));
+    if (allPaths.length > MAX_FILES) break;
   }
-  const cloudStorage = path7.join(home, "Library", "CloudStorage");
-  try {
-    if (fs5.existsSync(cloudStorage) && fs5.statSync(cloudStorage).isDirectory()) {
-      const entries = fs5.readdirSync(cloudStorage, { withFileTypes: true });
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue;
-        const fullPath = path7.join(cloudStorage, entry.name);
-        if (!dirs.includes(fullPath)) {
-          dirs.push(fullPath);
-        }
+  const pathsToProcess = allPaths.slice(0, MAX_FILES);
+  for (const filePath of pathsToProcess) {
+    try {
+      const stat = fs7.statSync(filePath);
+      onProgress?.({ phase: "parsing", message: displayPath(filePath) });
+      const content = await extractTextFromFile(filePath);
+      if (content && content.trim()) {
+        const category = getFileCategory(filePath);
+        files.push({
+          path: filePath,
+          displayPath: displayPath(filePath),
+          content,
+          format: category === "document" ? path10.extname(filePath).slice(1) : "text",
+          sizeBytes: stat.size,
+          folder: path10.dirname(filePath)
+        });
       }
+    } catch {
     }
-  } catch {
-  }
-  if (dirs.length === 0) {
-    dirs.push(home);
   }
-  return dirs;
+  return files;
 }
-function scanForBrain(folders, onProgress) {
-  const scanDirs = folders || getDefaultScanDirs();
+async function scanFolders(dirs, onProgress) {
+  const allFiles = await scanFilesInDirs(dirs, onProgress);
+  const folders = groupFilesByFolder(allFiles);
+  const projects = detectProjects(dirs, onProgress);
+  const configFiles = collectConfigFiles(projects, onProgress);
+  const totalFiles = allFiles.length;
+  const totalBytes = allFiles.reduce((sum, f) => sum + f.sizeBytes, 0);
+  return { folders, configFiles, projects, allFiles, totalFiles, totalBytes };
+}
+function buildBrainInput(scanResult, selectedFolderPaths) {
+  const selectedSet = new Set(selectedFolderPaths);
+  const selectedFiles = scanResult.allFiles.filter((f) => selectedSet.has(f.folder));
   const folderTree = [];
-  for (const dir of scanDirs) {
-    folderTree.push(`${path7.basename(dir)}/`);
-    folderTree.push(...getFolderTree(dir, 1));
+  for (const folder of scanResult.folders) {
+    if (selectedSet.has(folder.path)) {
+      folderTree.push(`${folder.displayPath}/ (${folder.fileCount} files)`);
+    }
   }
-  const projects = detectProjects(scanDirs, onProgress);
-  const configFiles = collectConfigFiles(projects, onProgress);
-  const recentDocuments = collectRecentDocs(projects, onProgress);
+  const personalDocuments = selectedFiles.map((f) => ({
+    name: f.displayPath,
+    content: f.content,
+    format: f.format
+  }));
   return {
     summary: {
       folders: folderTree,
-      projects: projects.map((p) => ({
+      projects: scanResult.projects.map((p) => ({
         name: p.name,
-        path: p.path.replace(home, "~"),
+        path: p.path.replace(home2, "~"),
         description: p.description
       })),
-      configFiles,
-      recentDocuments
+      configFiles: scanResult.configFiles,
+      recentDocuments: [],
+      personalDocuments
     }
   };
 }
@@ -1214,14 +1687,14 @@ function scanForProjects(folders) {
 }
 
 // src/lib/store.ts
-import fs6 from "fs";
-import path8 from "path";
-import os5 from "os";
-var CONFIG_DIR = path8.join(os5.homedir(), ".piut");
-var CONFIG_FILE2 = path8.join(CONFIG_DIR, "config.json");
+import fs8 from "fs";
+import path11 from "path";
+import os6 from "os";
+var CONFIG_DIR = path11.join(os6.homedir(), ".piut");
+var CONFIG_FILE2 = path11.join(CONFIG_DIR, "config.json");
 function readStore() {
   try {
-    const raw = fs6.readFileSync(CONFIG_FILE2, "utf-8");
+    const raw = fs8.readFileSync(CONFIG_FILE2, "utf-8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -1230,13 +1703,13 @@ function readStore() {
 function updateStore(updates) {
   const config = readStore();
   const updated = { ...config, ...updates };
-  fs6.mkdirSync(CONFIG_DIR, { recursive: true });
-  fs6.writeFileSync(CONFIG_FILE2, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+  fs8.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs8.writeFileSync(CONFIG_FILE2, JSON.stringify(updated, null, 2) + "\n", "utf-8");
   return updated;
 }
 function clearStore() {
   try {
-    fs6.unlinkSync(CONFIG_FILE2);
+    fs8.unlinkSync(CONFIG_FILE2);
   } catch {
   }
 }
@@ -1252,7 +1725,7 @@ var PIUT_FILES = [
 ];
 function hasPiutReference(filePath) {
   try {
-    const content = fs7.readFileSync(filePath, "utf-8");
+    const content = fs9.readFileSync(filePath, "utf-8");
     return content.includes("p\u0131ut Context") || content.includes("piut Context");
   } catch {
     return false;
@@ -1270,7 +1743,7 @@ async function statusCommand(options = {}) {
   for (const tool of TOOLS) {
     const paths = resolveConfigPaths(tool.configPaths);
     for (const configPath of paths) {
-      if (!fs7.existsSync(configPath)) continue;
+      if (!fs9.existsSync(configPath)) continue;
       foundAny = true;
       const configured = isPiutConfigured(configPath, tool.configKey);
       if (configured) {
@@ -1293,8 +1766,8 @@ async function statusCommand(options = {}) {
   for (const project of projects) {
     const connectedFiles = [];
     for (const file of PIUT_FILES) {
-      const absPath = path9.join(project.path, file);
-      if (fs7.existsSync(absPath) && hasPiutReference(absPath)) {
+      const absPath = path12.join(project.path, file);
+      if (fs9.existsSync(absPath) && hasPiutReference(absPath)) {
         connectedFiles.push(file);
       }
     }
@@ -1340,7 +1813,7 @@ async function verifyStatus() {
   for (const tool of TOOLS) {
     const paths = resolveConfigPaths(tool.configPaths);
     for (const configPath of paths) {
-      if (!fs7.existsSync(configPath)) continue;
+      if (!fs9.existsSync(configPath)) continue;
       const piutConfig = getPiutConfig(configPath, tool.configKey);
       if (!piutConfig) {
         toolLine(tool.name, dim("installed, not connected"), "\u25CB");
@@ -1383,7 +1856,7 @@ async function verifyStatus() {
 }
 
 // src/commands/remove.ts
-import fs8 from "fs";
+import fs10 from "fs";
 import { checkbox as checkbox2, confirm as confirm2 } from "@inquirer/prompts";
 async function removeCommand() {
   banner();
@@ -1391,7 +1864,7 @@ async function removeCommand() {
   for (const tool of TOOLS) {
     const paths = resolveConfigPaths(tool.configPaths);
     for (const configPath of paths) {
-      if (fs8.existsSync(configPath) && isPiutConfigured(configPath, tool.configKey)) {
+      if (fs10.existsSync(configPath) && isPiutConfigured(configPath, tool.configKey)) {
         configured.push({ tool, configPath });
         break;
       }
@@ -1420,158 +1893,219 @@ async function removeCommand() {
   });
   if (!proceed) return;
   console.log();
+  const removedNames = [];
   for (const { tool, configPath } of selected) {
     const removed = removeFromConfig(configPath, tool.configKey);
     if (removed) {
+      removedNames.push(tool.name);
       toolLine(tool.name, success("removed"), "\u2714");
     } else {
       toolLine(tool.name, warning("not found"), "\xD7");
     }
   }
+  const store = readStore();
+  if (store.apiKey && removedNames.length > 0) {
+    deleteConnections(store.apiKey, removedNames).catch(() => {
+    });
+  }
   console.log();
   console.log(dim("  Restart your AI tools for changes to take effect."));
   console.log();
 }
 
 // src/commands/build.ts
-import { select, checkbox as checkbox3, input, confirm as confirm3 } from "@inquirer/prompts";
+import { select as select2, checkbox as checkbox3, input as input2, confirm as confirm3 } from "@inquirer/prompts";
 import chalk5 from "chalk";
-import os6 from "os";
+import os7 from "os";
 
 // src/lib/auth.ts
-import { password as password2 } from "@inquirer/prompts";
+import { select, input, password as password2 } from "@inquirer/prompts";
+import { exec } from "child_process";
 import chalk4 from "chalk";
-async function resolveApiKey(keyOption) {
-  const config = readStore();
-  let apiKey = keyOption || config.apiKey;
-  if (!apiKey) {
-    apiKey = await password2({
-      message: "Enter your p\u0131ut API key:",
-      mask: "*",
-      validate: (v) => v.startsWith("pb_") || "Key must start with pb_"
-    });
-  }
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  exec(`${cmd} "${url}"`);
+}
+async function loginWithEmailFlow() {
+  const email = await input({
+    message: "Email:",
+    validate: (v) => v.includes("@") || "Enter a valid email address"
+  });
+  const pw = await password2({
+    message: "Password:",
+    mask: "*"
+  });
+  console.log(dim("  Authenticating..."));
+  const result = await loginWithEmail(email, pw);
+  return {
+    apiKey: result.apiKey,
+    validation: {
+      slug: result.slug,
+      displayName: result.displayName,
+      serverUrl: result.serverUrl,
+      planType: result.planType,
+      status: result.status,
+      _contractVersion: result._contractVersion
+    }
+  };
+}
+async function pasteKeyFlow() {
+  const apiKey = await password2({
+    message: "Enter your p\u0131ut API key:",
+    mask: "*",
+    validate: (v) => v.startsWith("pb_") || "Key must start with pb_"
+  });
   console.log(dim("  Validating key..."));
-  let result;
-  try {
-    result = await validateKey(apiKey);
-  } catch (err) {
-    console.log(chalk4.red(`  \u2717 ${err.message}`));
-    console.log(dim("  Get a key at https://piut.com/dashboard/keys"));
-    throw new CliError(err.message);
+  const validation = await validateKey(apiKey);
+  return { apiKey, validation };
+}
+async function browserFlow() {
+  const url = "https://piut.com/dashboard/keys";
+  console.log(dim(`  Opening ${brand(url)}...`));
+  openBrowser(url);
+  console.log(dim("  Copy your API key from the dashboard, then paste it here."));
+  console.log();
+  return pasteKeyFlow();
+}
+async function promptLogin() {
+  const method = await select({
+    message: "How would you like to connect?",
+    choices: [
+      {
+        name: "Log in with email",
+        value: "email",
+        description: "Use your p\u0131ut email and password"
+      },
+      {
+        name: "Log in with browser",
+        value: "browser",
+        description: "Open piut.com to get your API key"
+      },
+      {
+        name: "Paste API key",
+        value: "api-key",
+        description: "Enter an API key directly"
+      }
+    ]
+  });
+  switch (method) {
+    case "email":
+      return loginWithEmailFlow();
+    case "browser":
+      return browserFlow();
+    case "api-key":
+      return pasteKeyFlow();
   }
-  const label = result.slug ? `${result.displayName} (${result.slug})` : result.displayName;
-  console.log(success(`  \u2713 Connected as ${label}`));
-  updateStore({ apiKey });
-  return apiKey;
 }
 async function resolveApiKeyWithResult(keyOption) {
   const config = readStore();
   let apiKey = keyOption || config.apiKey;
-  if (!apiKey) {
-    apiKey = await password2({
-      message: "Enter your p\u0131ut API key:",
-      mask: "*",
-      validate: (v) => v.startsWith("pb_") || "Key must start with pb_"
-    });
+  if (apiKey) {
+    console.log(dim("  Validating key..."));
+    let result;
+    try {
+      result = await validateKey(apiKey);
+    } catch (err) {
+      console.log(chalk4.red(`  \u2717 ${err.message}`));
+      console.log(dim("  Get a key at https://piut.com/dashboard/keys"));
+      throw new CliError(err.message);
+    }
+    const label = result.slug ? `${result.displayName} (${result.slug})` : result.displayName;
+    console.log(success(`  \u2713 Connected as ${label}`));
+    updateStore({ apiKey });
+    return { apiKey, ...result };
   }
-  console.log(dim("  Validating key..."));
-  let result;
   try {
-    result = await validateKey(apiKey);
+    const { apiKey: newKey, validation } = await promptLogin();
+    const label = validation.slug ? `${validation.displayName} (${validation.slug})` : validation.displayName;
+    console.log(success(`  \u2713 Connected as ${label}`));
+    updateStore({ apiKey: newKey });
+    return { apiKey: newKey, ...validation };
   } catch (err) {
     console.log(chalk4.red(`  \u2717 ${err.message}`));
-    console.log(dim("  Get a key at https://piut.com/dashboard/keys"));
     throw new CliError(err.message);
   }
-  const label = result.slug ? `${result.displayName} (${result.slug})` : result.displayName;
-  console.log(success(`  \u2713 Connected as ${label}`));
-  updateStore({ apiKey });
-  return { apiKey, ...result };
 }
 
 // src/commands/build.ts
 async function buildCommand(options) {
   banner();
-  const apiKey = await resolveApiKey(options.key);
-  let scanFolders;
+  const { apiKey, serverUrl } = await resolveApiKeyWithResult(options.key);
+  let scanDirs;
   if (options.folders) {
-    scanFolders = options.folders.split(",").map((f) => expandPath(f.trim()));
-  }
-  const cwd = process.cwd();
-  const cwdDisplay = cwd.replace(os6.homedir(), "~");
-  if (!scanFolders) {
-    console.log(dim(`  Current directory: `) + cwdDisplay);
-    console.log(dim(`  We'll scan for AI config files and projects here.`));
+    scanDirs = options.folders.split(",").map((f) => expandPath(f.trim()));
+  } else {
+    console.log(dim("  \u2501\u2501\u2501 BUILD YOUR BRAIN \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
     console.log();
-    const mode = await select({
-      message: "How do you want to build your brain?",
-      choices: [
-        { name: `Scan this directory (${cwdDisplay})`, value: "cwd", description: "Scan current directory for projects and config files" },
-        { name: "Select folder(s)...", value: "folders", description: "Choose a different directory to scan" }
-      ]
-    });
-    if (mode === "cwd") {
-      scanFolders = [cwd];
-    } else {
-      const defaults = getDefaultScanDirs();
-      const CUSTOM_VALUE = "__custom__";
-      const choices = [
-        ...defaults.map((d) => ({ name: d.replace(os6.homedir(), "~"), value: d })),
-        { name: chalk5.dim("Enter a custom path..."), value: CUSTOM_VALUE }
-      ];
-      const selected = await checkbox3({
-        message: "Which folders should we scan?",
-        choices,
-        required: true
-      });
-      if (selected.includes(CUSTOM_VALUE)) {
-        const custom = await input({
-          message: "Enter folder path(s), comma-separated:"
-        });
-        const customPaths = custom.split(",").map((f) => expandPath(f.trim())).filter(Boolean);
-        scanFolders = [
-          ...selected.filter((v) => v !== CUSTOM_VALUE),
-          ...customPaths
-        ];
-      } else {
-        scanFolders = selected;
-      }
-      if (scanFolders.length === 0) {
-        console.log(chalk5.yellow("  No folders selected."));
-        return;
-      }
-    }
+    console.log(dim("  This is a local scan only \u2014 no files leave your machine"));
+    console.log(dim("  until you review and explicitly approve."));
+    console.log();
+    scanDirs = await selectFolders();
+  }
+  if (scanDirs.length === 0) {
+    console.log(chalk5.yellow("  No folders selected."));
+    return;
   }
   console.log();
-  let projectCount = 0;
-  let configCount = 0;
-  let docCount = 0;
+  console.log(dim("  Scanning locally \u2014 no data is shared..."));
+  console.log();
+  let fileCount = 0;
   const onProgress = (progress) => {
-    if (progress.phase === "projects") {
-      projectCount++;
-      console.log(dim(`  [${projectCount}] ${progress.message}`));
+    if (progress.phase === "scanning") {
+      console.log(dim(`  ${progress.message}`));
+    } else if (progress.phase === "parsing") {
+      fileCount++;
+      console.log(dim(`    [${fileCount}] ${progress.message}`));
+    } else if (progress.phase === "projects") {
+      console.log(dim(`  [project] ${progress.message}`));
     } else if (progress.phase === "configs") {
-      configCount++;
-      console.log(dim(`  [${configCount}] ${progress.message}`));
-    } else if (progress.phase === "docs") {
-      docCount++;
-      console.log(dim(`  [${docCount}] ${progress.message}`));
+      console.log(dim(`  [config] ${progress.message}`));
     }
   };
-  const brainInput = scanForBrain(scanFolders, onProgress);
-  const projCount = brainInput.summary.projects.length;
-  const cfgCount = brainInput.summary.configFiles.length;
-  const dcCount = brainInput.summary.recentDocuments.length;
+  const scanResult = await scanFolders(scanDirs, onProgress);
   console.log();
-  console.log(success(`  Scanned: ${projCount} projects, ${cfgCount} config files, ${dcCount} recent docs`));
+  console.log(success(`  \u2713 Scan complete: ${scanResult.totalFiles} files found across ${scanResult.folders.length} folders (local only)`));
   console.log();
-  if (projCount === 0 && cfgCount === 0) {
-    console.log(chalk5.yellow("  No projects or config files found to build from."));
-    console.log(dim("  Try running from a directory with your projects, or use --folders."));
+  if (scanResult.totalFiles === 0 && scanResult.configFiles.length === 0) {
+    console.log(chalk5.yellow("  No parseable files found in the selected folders."));
+    console.log(dim("  Try scanning a different directory, or use --folders to specify paths."));
     console.log();
     return;
   }
+  let selectedFolderPaths;
+  if (options.yes || scanResult.folders.length === 0) {
+    selectedFolderPaths = scanResult.folders.map((f) => f.path);
+  } else {
+    selectedFolderPaths = await reviewFolders(scanResult);
+  }
+  if (selectedFolderPaths.length === 0 && scanResult.configFiles.length === 0) {
+    console.log(chalk5.yellow("  No folders selected."));
+    return;
+  }
+  const selectedFolders = scanResult.folders.filter((f) => selectedFolderPaths.includes(f.path));
+  const totalSelectedFiles = selectedFolders.reduce((sum, f) => sum + f.fileCount, 0) + scanResult.configFiles.length;
+  if (!options.yes) {
+    console.log();
+    console.log(dim("  \u2501\u2501\u2501 READY TO BUILD \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
+    console.log();
+    console.log(dim(`  ${totalSelectedFiles} files will be sent to p\u0131ut and processed by Claude`));
+    console.log(dim("  Sonnet to design your brain. File contents are used for"));
+    console.log(dim("  brain generation only and are not retained."));
+    console.log();
+    console.log(dim(`  Privacy policy: ${brand("https://piut.com/privacy")}`));
+    console.log();
+    const consent = await confirm3({
+      message: "Send files and build your brain?",
+      default: false
+    });
+    if (!consent) {
+      console.log();
+      console.log(dim("  Build cancelled. No files were sent."));
+      console.log();
+      return;
+    }
+  }
+  const brainInput = buildBrainInput(scanResult, selectedFolderPaths);
   const spinner = new Spinner();
   spinner.start("Generating brain...");
   try {
@@ -1587,6 +2121,7 @@ async function buildCommand(options) {
           spinner.addSection(String(event.data.name));
           break;
         case "complete":
+          spinner.completeAll();
           sections = event.data.sections || {};
           break;
         case "error":
@@ -1629,15 +2164,25 @@ async function buildCommand(options) {
     }
     console.log(dim(`  Review and edit at ${brand("piut.com/dashboard")}`));
     console.log();
-    const wantPublish = options.publish === false ? false : options.yes ? true : await confirm3({
-      message: "Publish your brain now?",
-      default: true
-    });
+    let wantPublish;
+    if (options.publish === false) {
+      wantPublish = false;
+    } else if (options.yes) {
+      wantPublish = true;
+    } else {
+      console.log(dim("  You can always make changes later."));
+      wantPublish = await confirm3({
+        message: "Publish your brain now?",
+        default: true
+      });
+    }
     if (wantPublish) {
       try {
         await publishServer(apiKey);
         console.log();
         console.log(success("  \u2713 Brain published. MCP server is live."));
+        console.log(`  ${brand(serverUrl)}`);
+        console.log(dim("  (accessible only with secure authentication)"));
         console.log();
       } catch (err) {
         console.log();
@@ -1665,6 +2210,78 @@ async function buildCommand(options) {
     throw new CliError(hint);
   }
 }
+async function selectFolders() {
+  const defaults = getDefaultScanDirs();
+  const homeDir = os7.homedir();
+  const ALL_VALUE = "__all__";
+  const CUSTOM_VALUE = "__custom__";
+  const choices = [
+    { name: `All home folders (~) ${chalk5.dim("(Recommended)")}`, value: ALL_VALUE },
+    { name: chalk5.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"), value: "__sep__", disabled: true },
+    ...defaults.map((d) => ({ name: displayPath(d), value: d })),
+    { name: chalk5.dim("Browse to a folder..."), value: CUSTOM_VALUE }
+  ];
+  const selected = await checkbox3({
+    message: "Select folders to scan:",
+    choices,
+    required: true
+  });
+  let scanDirs;
+  if (selected.includes(ALL_VALUE)) {
+    scanDirs = defaults;
+  } else {
+    scanDirs = selected.filter((v) => v !== CUSTOM_VALUE);
+    if (selected.includes(CUSTOM_VALUE)) {
+      const custom = await input2({
+        message: "Enter folder path(s), comma-separated:"
+      });
+      const customPaths = custom.split(",").map((f) => expandPath(f.trim())).filter(Boolean);
+      scanDirs = [...scanDirs, ...customPaths];
+    }
+  }
+  if (scanDirs.length > 0 && !selected.includes(ALL_VALUE)) {
+    console.log();
+    console.log(dim("  Selected:"));
+    for (const d of scanDirs) {
+      console.log(dim(`    ${displayPath(d)}`));
+    }
+    const addMore = await select2({
+      message: "Add more folders or continue?",
+      choices: [
+        { name: "Continue with scan", value: "continue" },
+        { name: "Add another folder...", value: "add" }
+      ]
+    });
+    if (addMore === "add") {
+      const extra = await input2({
+        message: "Enter folder path(s), comma-separated:"
+      });
+      const extraPaths = extra.split(",").map((f) => expandPath(f.trim())).filter(Boolean);
+      scanDirs = [...scanDirs, ...extraPaths];
+    }
+  }
+  return scanDirs;
+}
+async function reviewFolders(scanResult) {
+  if (scanResult.folders.length === 0) return [];
+  console.log(dim("  \u2501\u2501\u2501 REVIEW SCANNED FOLDERS \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
+  console.log();
+  console.log(dim("  All folders selected by default. Deselect any you want to exclude."));
+  console.log();
+  const choices = scanResult.folders.map((folder) => ({
+    name: formatFolderChoice(folder),
+    value: folder.path,
+    checked: true
+  }));
+  const selected = await checkbox3({
+    message: "Select folders to include in your brain:",
+    choices
+  });
+  const selectedFolders = scanResult.folders.filter((f) => selected.includes(f.path));
+  console.log();
+  console.log(dim(`  ${formatSelectionSummary(selectedFolders)}`));
+  return selected;
+}
 
 // src/commands/deploy.ts
 import chalk6 from "chalk";
@@ -1704,33 +2321,33 @@ async function deployCommand(options) {
 }
 
 // src/commands/connect.ts
-import fs9 from "fs";
-import path10 from "path";
+import fs11 from "fs";
+import path13 from "path";
 import { checkbox as checkbox4 } from "@inquirer/prompts";
 var RULE_FILES = [
   {
     tool: "Claude Code",
     filePath: "CLAUDE.md",
     strategy: "append",
-    detect: (p) => p.hasClaudeMd || fs9.existsSync(path10.join(p.path, ".claude"))
+    detect: (p) => p.hasClaudeMd || fs11.existsSync(path13.join(p.path, ".claude"))
   },
   {
     tool: "Cursor",
     filePath: ".cursor/rules/piut.mdc",
     strategy: "create",
-    detect: (p) => p.hasCursorRules || fs9.existsSync(path10.join(p.path, ".cursor"))
+    detect: (p) => p.hasCursorRules || fs11.existsSync(path13.join(p.path, ".cursor"))
   },
   {
     tool: "Windsurf",
     filePath: ".windsurf/rules/piut.md",
     strategy: "create",
-    detect: (p) => p.hasWindsurfRules || fs9.existsSync(path10.join(p.path, ".windsurf"))
+    detect: (p) => p.hasWindsurfRules || fs11.existsSync(path13.join(p.path, ".windsurf"))
   },
   {
     tool: "GitHub Copilot",
     filePath: ".github/copilot-instructions.md",
     strategy: "append",
-    detect: (p) => p.hasCopilotInstructions || fs9.existsSync(path10.join(p.path, ".github"))
+    detect: (p) => p.hasCopilotInstructions || fs11.existsSync(path13.join(p.path, ".github"))
   },
   {
     tool: "Amazon Q",
@@ -1742,7 +2359,7 @@ var RULE_FILES = [
     tool: "Zed",
     filePath: ".zed/rules.md",
     strategy: "create",
-    detect: (p) => p.hasZedRules || fs9.existsSync(path10.join(p.path, ".zed"))
+    detect: (p) => p.hasZedRules || fs11.existsSync(path13.join(p.path, ".zed"))
   }
 ];
 var DEDICATED_FILE_CONTENT = `## p\u0131ut Context (MCP Server: piut-context)
@@ -1777,7 +2394,7 @@ Full skill reference: .piut/skill.md
 `;
 function hasPiutReference2(filePath) {
   try {
-    const content = fs9.readFileSync(filePath, "utf-8");
+    const content = fs11.readFileSync(filePath, "utf-8");
     return content.includes("p\u0131ut Context") || content.includes("piut Context");
   } catch {
     return false;
@@ -1800,13 +2417,13 @@ async function connectCommand(options) {
     console.log();
     return;
   }
-  let scanFolders;
+  let scanFolders2;
   if (options.folders) {
-    scanFolders = options.folders.split(",").map((f) => expandPath(f.trim()));
+    scanFolders2 = options.folders.split(",").map((f) => expandPath(f.trim()));
   }
   console.log();
   console.log(dim("  Scanning for projects..."));
-  const projects = scanForProjects(scanFolders);
+  const projects = scanForProjects(scanFolders2);
   if (projects.length === 0) {
     console.log(warning("  No projects found."));
     console.log(dim("  Try running from a directory with your projects, or use --folders."));
@@ -1817,20 +2434,20 @@ async function connectCommand(options) {
   for (const project of projects) {
     for (const rule of RULE_FILES) {
       if (!rule.detect(project)) continue;
-      const absPath = path10.join(project.path, rule.filePath);
-      if (fs9.existsSync(absPath) && hasPiutReference2(absPath)) continue;
+      const absPath = path13.join(project.path, rule.filePath);
+      if (fs11.existsSync(absPath) && hasPiutReference2(absPath)) continue;
       actions.push({
         project,
         tool: rule.tool,
         filePath: rule.filePath,
         absPath,
-        action: rule.strategy === "create" || !fs9.existsSync(absPath) ? "create" : "append"
+        action: rule.strategy === "create" || !fs11.existsSync(absPath) ? "create" : "append"
       });
     }
     const hasAnyAction = actions.some((a) => a.project === project);
     if (!hasAnyAction) {
-      const claudeMdPath = path10.join(project.path, "CLAUDE.md");
-      if (!fs9.existsSync(claudeMdPath)) {
+      const claudeMdPath = path13.join(project.path, "CLAUDE.md");
+      if (!fs11.existsSync(claudeMdPath)) {
         actions.push({
           project,
           tool: "Claude Code",
@@ -1870,7 +2487,7 @@ async function connectCommand(options) {
   console.log();
   const projectChoices = [];
   for (const [projectPath, projectActions] of byProject) {
-    const projectName = path10.basename(projectPath);
+    const projectName = path13.basename(projectPath);
     const desc = projectActions.map((a) => {
       const verb = a.action === "create" ? "will create" : "will append to";
       return `${verb} ${a.filePath}`;
@@ -1899,15 +2516,15 @@ async function connectCommand(options) {
   const copilotTool = TOOLS.find((t) => t.id === "copilot");
   for (const projectPath of selectedPaths) {
     const projectActions = byProject.get(projectPath) || [];
-    const projectName = path10.basename(projectPath);
+    const projectName = path13.basename(projectPath);
     writePiutConfig(projectPath, { slug, apiKey, serverUrl });
     await writePiutSkill(projectPath, slug, apiKey);
     ensureGitignored(projectPath);
     console.log(success(`  \u2713 ${projectName}/.piut/`) + dim(" \u2014 credentials + skill"));
     if (copilotTool) {
-      const hasCopilot = fs9.existsSync(path10.join(projectPath, ".github", "copilot-instructions.md")) || fs9.existsSync(path10.join(projectPath, ".github"));
+      const hasCopilot = fs11.existsSync(path13.join(projectPath, ".github", "copilot-instructions.md")) || fs11.existsSync(path13.join(projectPath, ".github"));
       if (hasCopilot) {
-        const vscodeMcpPath = path10.join(projectPath, ".vscode", "mcp.json");
+        const vscodeMcpPath = path13.join(projectPath, ".vscode", "mcp.json");
         const serverConfig = copilotTool.generateConfig(slug, apiKey);
         mergeConfig(vscodeMcpPath, copilotTool.configKey, serverConfig);
         console.log(success(`  \u2713 ${projectName}/.vscode/mcp.json`) + dim(" \u2014 Copilot MCP"));
@@ -1917,11 +2534,11 @@ async function connectCommand(options) {
       if (action.action === "create") {
         const isAppendType = RULE_FILES.find((r) => r.filePath === action.filePath)?.strategy === "append";
         const content = isAppendType ? PROJECT_SKILL_SNIPPET + "\n" : DEDICATED_FILE_CONTENT;
-        fs9.mkdirSync(path10.dirname(action.absPath), { recursive: true });
-        fs9.writeFileSync(action.absPath, content, "utf-8");
+        fs11.mkdirSync(path13.dirname(action.absPath), { recursive: true });
+        fs11.writeFileSync(action.absPath, content, "utf-8");
         console.log(success(`  \u2713 ${projectName}/${action.filePath}`) + dim(" \u2014 created"));
       } else {
-        fs9.appendFileSync(action.absPath, APPEND_SECTION);
+        fs11.appendFileSync(action.absPath, APPEND_SECTION);
         console.log(success(`  \u2713 ${projectName}/${action.filePath}`) + dim(" \u2014 appended"));
       }
       connected++;
@@ -1930,7 +2547,7 @@ async function connectCommand(options) {
   const machineId = getMachineId();
   for (const projectPath of selectedPaths) {
     const projectActions = byProject.get(projectPath) || [];
-    const projectName = path10.basename(projectPath);
+    const projectName = path13.basename(projectPath);
     const toolsDetected = [...new Set(projectActions.map((a) => a.tool))];
     const configFilesWritten = projectActions.map((a) => a.filePath);
     registerProject(apiKey, {
@@ -1948,8 +2565,8 @@ async function connectCommand(options) {
 }
 
 // src/commands/disconnect.ts
-import fs10 from "fs";
-import path11 from "path";
+import fs12 from "fs";
+import path14 from "path";
 import { checkbox as checkbox5, confirm as confirm5 } from "@inquirer/prompts";
 var DEDICATED_FILES = /* @__PURE__ */ new Set([
   ".cursor/rules/piut.mdc",
@@ -1963,7 +2580,7 @@ var APPEND_FILES = [
 ];
 function hasPiutReference3(filePath) {
   try {
-    const content = fs10.readFileSync(filePath, "utf-8");
+    const content = fs12.readFileSync(filePath, "utf-8");
     return content.includes("p\u0131ut Context") || content.includes("piut Context");
   } catch {
     return false;
@@ -1971,7 +2588,7 @@ function hasPiutReference3(filePath) {
 }
 function removePiutSection(filePath) {
   try {
-    let content = fs10.readFileSync(filePath, "utf-8");
+    let content = fs12.readFileSync(filePath, "utf-8");
     const patterns = [
       /\n*## p[ıi]ut Context[\s\S]*?(?=\n## |\n---\n|$)/g
     ];
@@ -1985,7 +2602,7 @@ function removePiutSection(filePath) {
     }
     if (changed) {
       content = content.replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
-      fs10.writeFileSync(filePath, content, "utf-8");
+      fs12.writeFileSync(filePath, content, "utf-8");
     }
     return changed;
   } catch {
@@ -1994,18 +2611,18 @@ function removePiutSection(filePath) {
 }
 async function disconnectCommand(options) {
   banner();
-  let scanFolders;
+  let scanFolders2;
   if (options.folders) {
-    scanFolders = options.folders.split(",").map((f) => expandPath(f.trim()));
+    scanFolders2 = options.folders.split(",").map((f) => expandPath(f.trim()));
   }
   console.log(dim("  Scanning for connected projects..."));
-  const projects = scanForProjects(scanFolders);
+  const projects = scanForProjects(scanFolders2);
   const actions = [];
   for (const project of projects) {
-    const projectName = path11.basename(project.path);
+    const projectName = path14.basename(project.path);
     for (const dedicatedFile of DEDICATED_FILES) {
-      const absPath = path11.join(project.path, dedicatedFile);
-      if (fs10.existsSync(absPath) && hasPiutReference3(absPath)) {
+      const absPath = path14.join(project.path, dedicatedFile);
+      if (fs12.existsSync(absPath) && hasPiutReference3(absPath)) {
         actions.push({
           projectPath: project.path,
           projectName,
@@ -2016,8 +2633,8 @@ async function disconnectCommand(options) {
       }
     }
     for (const appendFile of APPEND_FILES) {
-      const absPath = path11.join(project.path, appendFile);
-      if (fs10.existsSync(absPath) && hasPiutReference3(absPath)) {
+      const absPath = path14.join(project.path, appendFile);
+      if (fs12.existsSync(absPath) && hasPiutReference3(absPath)) {
         actions.push({
           projectPath: project.path,
           projectName,
@@ -2032,12 +2649,12 @@ async function disconnectCommand(options) {
         projectPath: project.path,
         projectName,
         filePath: ".piut/",
-        absPath: path11.join(project.path, ".piut"),
+        absPath: path14.join(project.path, ".piut"),
         action: "remove-dir"
       });
     }
-    const vscodeMcpPath = path11.join(project.path, ".vscode", "mcp.json");
-    if (fs10.existsSync(vscodeMcpPath) && isPiutConfigured(vscodeMcpPath, "servers")) {
+    const vscodeMcpPath = path14.join(project.path, ".vscode", "mcp.json");
+    if (fs12.existsSync(vscodeMcpPath) && isPiutConfigured(vscodeMcpPath, "servers")) {
       actions.push({
         projectPath: project.path,
         projectName,
@@ -2059,7 +2676,7 @@ async function disconnectCommand(options) {
   }
   console.log();
   const projectChoices = Array.from(byProject.entries()).map(([projectPath, projectActions]) => {
-    const name = path11.basename(projectPath);
+    const name = path14.basename(projectPath);
     const files = projectActions.map((a) => a.filePath).join(", ");
     return {
       name: `${name} ${dim(`(${files})`)}`,
@@ -2088,11 +2705,11 @@ async function disconnectCommand(options) {
   let disconnected = 0;
   for (const projectPath of selectedPaths) {
     const projectActions = byProject.get(projectPath) || [];
-    const projectName = path11.basename(projectPath);
+    const projectName = path14.basename(projectPath);
     for (const action of projectActions) {
       if (action.action === "delete") {
         try {
-          fs10.unlinkSync(action.absPath);
+          fs12.unlinkSync(action.absPath);
           console.log(success(`  \u2713 ${projectName}/${action.filePath}`) + dim(" \u2014 deleted"));
           disconnected++;
         } catch {
@@ -2135,6 +2752,21 @@ async function disconnectCommand(options) {
   console.log();
 }
 
+// src/commands/login.ts
+import chalk7 from "chalk";
+async function loginCommand() {
+  try {
+    const { apiKey, validation } = await promptLogin();
+    const label = validation.slug ? `${validation.displayName} (${validation.slug})` : validation.displayName;
+    console.log(success(`  \u2713 Connected as ${label}`));
+    updateStore({ apiKey });
+    console.log(dim("  API key saved. You can now use all p\u0131ut commands."));
+  } catch (err) {
+    console.log(chalk7.red(`  \u2717 ${err.message}`));
+    throw new CliError(err.message);
+  }
+}
+
 // src/commands/logout.ts
 async function logoutCommand() {
   banner();
@@ -2152,11 +2784,11 @@ async function logoutCommand() {
 }
 
 // src/commands/update.ts
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 
 // src/lib/update-check.ts
 import { execFile } from "child_process";
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 import { confirm as confirm6 } from "@inquirer/prompts";
 var PACKAGE_NAME = "@piut/cli";
 function isNpx() {
@@ -2193,7 +2825,7 @@ async function checkForUpdate(currentVersion) {
   const updateCmd = npx ? `npx ${PACKAGE_NAME}@latest` : `npm install -g ${PACKAGE_NAME}@latest`;
   console.log();
   console.log(brand("  Update available!") + dim(` ${currentVersion} \u2192 ${latest}`));
-  console.log(dim(`  Run ${chalk7.bold(updateCmd)} to update`));
+  console.log(dim(`  Run ${chalk8.bold(updateCmd)} to update`));
   console.log();
   if (npx) return;
   try {
@@ -2205,12 +2837,12 @@ async function checkForUpdate(currentVersion) {
       console.log(dim("  Updating..."));
       const ok = await runUpdate();
       if (ok) {
-        console.log(chalk7.green(`  \u2713 Updated to v${latest}`));
+        console.log(chalk8.green(`  \u2713 Updated to v${latest}`));
         console.log(dim("  Restart the CLI to use the new version."));
         process.exit(0);
       } else {
-        console.log(chalk7.yellow(`  Could not auto-update. Run manually:`));
-        console.log(chalk7.bold(`  npm install -g ${PACKAGE_NAME}@latest`));
+        console.log(chalk8.yellow(`  Could not auto-update. Run manually:`));
+        console.log(chalk8.bold(`  npm install -g ${PACKAGE_NAME}@latest`));
         console.log();
       }
     }
@@ -2225,7 +2857,7 @@ async function updateCommand(currentVersion) {
   console.log(dim("  Checking for updates..."));
   const latest = await getLatestVersion();
   if (!latest) {
-    console.log(chalk8.yellow("  Could not reach the npm registry. Check your connection."));
+    console.log(chalk9.yellow("  Could not reach the npm registry. Check your connection."));
     return;
   }
   if (!isNewer(currentVersion, latest)) {
@@ -2237,7 +2869,7 @@ async function updateCommand(currentVersion) {
   if (isNpx()) {
     console.log();
     console.log(dim("  You're running via npx. Use the latest version with:"));
-    console.log(chalk8.bold(`  npx ${PACKAGE_NAME2}@latest`));
+    console.log(chalk9.bold(`  npx ${PACKAGE_NAME2}@latest`));
     console.log();
     return;
   }
@@ -2247,14 +2879,14 @@ async function updateCommand(currentVersion) {
     console.log(success(`  \u2713 Updated to v${latest}`));
     console.log(dim("  Restart the CLI to use the new version."));
   } else {
-    console.log(chalk8.yellow("  Could not auto-update. Run manually:"));
-    console.log(chalk8.bold(`  npm install -g ${PACKAGE_NAME2}@latest`));
+    console.log(chalk9.yellow("  Could not auto-update. Run manually:"));
+    console.log(chalk9.bold(`  npm install -g ${PACKAGE_NAME2}@latest`));
   }
 }
 
 // src/commands/doctor.ts
-import fs11 from "fs";
-import chalk9 from "chalk";
+import fs13 from "fs";
+import chalk10 from "chalk";
 async function doctorCommand(options) {
   if (!options.json) banner();
   const result = {
@@ -2305,7 +2937,7 @@ async function doctorCommand(options) {
   for (const tool of TOOLS) {
     const paths = resolveConfigPaths(tool.configPaths);
     for (const configPath of paths) {
-      if (!fs11.existsSync(configPath)) continue;
+      if (!fs13.existsSync(configPath)) continue;
       const piutConfig = getPiutConfig(configPath, tool.configKey);
       if (!piutConfig) {
         result.tools.push({
@@ -2410,10 +3042,10 @@ async function doctorCommand(options) {
     const staleTools = result.tools.filter((t) => t.keyMatch === "stale" && !t.fixed);
     if (staleTools.length > 0 && !options.fix) {
       console.log();
-      console.log(dim("  Fix stale configs: ") + chalk9.cyan("piut doctor --fix"));
+      console.log(dim("  Fix stale configs: ") + chalk10.cyan("piut doctor --fix"));
     }
     if (!result.key.valid) {
-      console.log(dim("  Set a valid key: ") + chalk9.cyan("piut setup --key pb_YOUR_KEY"));
+      console.log(dim("  Set a valid key: ") + chalk10.cyan("piut setup --key pb_YOUR_KEY"));
     }
   }
   console.log();
@@ -2421,48 +3053,38 @@ async function doctorCommand(options) {
 }
 
 // src/commands/interactive.ts
-import { select as select2, confirm as confirm7, checkbox as checkbox6, password as password3 } from "@inquirer/prompts";
-import fs12 from "fs";
-import path12 from "path";
-import chalk10 from "chalk";
+import { select as select3, confirm as confirm7, checkbox as checkbox6, Separator } from "@inquirer/prompts";
+import fs14 from "fs";
+import path15 from "path";
+import { exec as exec2 } from "child_process";
+import os8 from "os";
+import chalk11 from "chalk";
 async function authenticate() {
   const config = readStore();
-  let apiKey = config.apiKey;
+  const apiKey = config.apiKey;
   if (apiKey) {
     try {
-      const result2 = await validateKey(apiKey);
-      console.log(success(`  Connected as ${result2.displayName}`));
-      return { apiKey, validation: result2 };
+      const result = await validateKey(apiKey);
+      console.log(success(`  Connected as ${result.displayName}`));
+      return { apiKey, validation: result };
     } catch {
       console.log(dim("  Saved key expired. Please re-authenticate."));
-      apiKey = void 0;
     }
   }
-  console.log(dim("  Connect to p\u0131ut:"));
-  console.log(dim("    > Log in at piut.com"));
-  console.log(dim("    > Enter p\u0131ut API key"));
-  console.log();
-  apiKey = await password3({
-    message: "Enter your p\u0131ut API key:",
-    mask: "*",
-    validate: (v) => v.startsWith("pb_") || "Key must start with pb_"
-  });
-  console.log(dim("  Validating key..."));
-  let result;
-  try {
-    result = await validateKey(apiKey);
-  } catch (err) {
-    console.log(chalk10.red(`  \u2717 ${err.message}`));
-    console.log(dim("  Get a key at https://piut.com/dashboard/keys"));
-    process.exit(1);
-  }
-  console.log(success(`  \u2713 Connected as ${result.displayName}`));
-  updateStore({ apiKey });
-  return { apiKey, validation: result };
+  const { apiKey: newKey, validation } = await promptLogin();
+  const label = validation.slug ? `${validation.displayName} (${validation.slug})` : validation.displayName;
+  console.log(success(`  \u2713 Connected as ${label}`));
+  updateStore({ apiKey: newKey });
+  return { apiKey: newKey, validation };
 }
 function isPromptCancellation(err) {
   return !!(err && typeof err === "object" && "name" in err && err.name === "ExitPromptError");
 }
+function openInBrowser(url) {
+  const platform = process.platform;
+  const cmd = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+  exec2(`${cmd} ${url}`);
+}
 async function interactiveMenu() {
   banner();
   let apiKey;
@@ -2508,42 +3130,39 @@ async function interactiveMenu() {
     const isDeployed = currentValidation.status === "active";
     let action;
     try {
-      action = await select2({
+      action = await select3({
         message: "What would you like to do?",
+        loop: false,
         choices: [
           {
-            name: hasBrain ? "Rebuild Brain" : "Build Brain",
+            name: hasBrain ? "Resync Brain" : "Build Brain",
             value: "build",
-            description: hasBrain ? "Rebuild your brain from your files" : "Build your brain from your files"
+            description: hasBrain ? "Rescan your files and merge updates into your brain" : "Build your brain from your files"
           },
           {
             name: isDeployed ? "Undeploy Brain" : "Deploy Brain",
             value: "deploy",
             description: isDeployed ? "Take your MCP server offline" : "Publish your MCP server (requires paid account)"
           },
+          new Separator(),
           {
             name: "Connect Tools",
             value: "connect-tools",
-            description: "Configure AI tools to use your MCP server",
-            disabled: !isDeployed && "(deploy brain first)"
-          },
-          {
-            name: "Disconnect Tools",
-            value: "disconnect-tools",
-            description: "Remove p\u0131ut from AI tool configs",
+            description: "Manage which AI tools use your MCP server",
             disabled: !isDeployed && "(deploy brain first)"
           },
           {
             name: "Connect Projects",
             value: "connect-projects",
-            description: "Add brain references to project config files",
+            description: "Manage brain references in project config files",
             disabled: !isDeployed && "(deploy brain first)"
           },
+          new Separator(),
           {
-            name: "Disconnect Projects",
-            value: "disconnect-projects",
-            description: "Remove brain references from project configs",
-            disabled: !isDeployed && "(deploy brain first)"
+            name: "Edit Brain",
+            value: "edit-brain",
+            description: "Open piut.com to edit your brain",
+            disabled: !hasBrain && "(build brain first)"
           },
           {
             name: "View Brain",
@@ -2556,6 +3175,7 @@ async function interactiveMenu() {
             value: "status",
             description: "Show brain, deployment, and connected tools/projects"
           },
+          new Separator(),
           {
             name: "Logout",
             value: "logout",
@@ -2575,7 +3195,11 @@ async function interactiveMenu() {
     try {
       switch (action) {
         case "build":
-          await buildCommand({ key: apiKey });
+          if (hasBrain) {
+            await handleResyncBrain(apiKey, currentValidation);
+          } else {
+            await buildCommand({ key: apiKey });
+          }
           break;
         case "deploy":
           if (isDeployed) {
@@ -2587,14 +3211,11 @@ async function interactiveMenu() {
         case "connect-tools":
           await handleConnectTools(apiKey, currentValidation);
           break;
-        case "disconnect-tools":
-          await handleDisconnectTools();
-          break;
         case "connect-projects":
-          await connectCommand({ key: apiKey });
+          await handleManageProjects(apiKey, currentValidation);
           break;
-        case "disconnect-projects":
-          await disconnectCommand({});
+        case "edit-brain":
+          handleEditBrain();
           break;
         case "view-brain":
           await handleViewBrain(apiKey);
@@ -2620,7 +3241,7 @@ async function interactiveMenu() {
       } else if (err instanceof CliError) {
         console.log();
       } else {
-        console.log(chalk10.red(`  Error: ${err.message}`));
+        console.log(chalk11.red(`  Error: ${err.message}`));
         console.log();
       }
     }
@@ -2643,115 +3264,291 @@ async function handleUndeploy(apiKey) {
     console.log(dim("  Run ") + brand("piut deploy") + dim(" to re-deploy anytime."));
     console.log();
   } catch (err) {
-    console.log(chalk10.red(`  \u2717 ${err.message}`));
+    console.log(chalk11.red(`  \u2717 ${err.message}`));
   }
 }
 async function handleConnectTools(apiKey, validation) {
   const { slug } = validation;
-  const unconfigured = [];
-  const alreadyConnected = [];
+  const detected = [];
   for (const tool of TOOLS) {
     const paths = resolveConfigPaths(tool.configPaths);
     for (const configPath of paths) {
-      const exists = fs12.existsSync(configPath);
-      const parentExists = fs12.existsSync(path12.dirname(configPath));
+      const exists = fs14.existsSync(configPath);
+      const parentExists = fs14.existsSync(path15.dirname(configPath));
       if (exists || parentExists) {
-        if (exists && isPiutConfigured(configPath, tool.configKey)) {
-          alreadyConnected.push(tool.name);
-        } else {
-          unconfigured.push({ tool, configPath });
-        }
+        const connected = exists && isPiutConfigured(configPath, tool.configKey);
+        detected.push({ tool, configPath, connected });
         break;
       }
     }
   }
-  if (unconfigured.length === 0) {
-    if (alreadyConnected.length > 0) {
-      console.log(dim("  All detected tools are already connected."));
-    } else {
-      console.log(warning("  No supported AI tools detected."));
-      console.log(dim("  Supported: Claude Code, Claude Desktop, Cursor, Windsurf, GitHub Copilot, Amazon Q, Zed"));
-    }
+  if (detected.length === 0) {
+    console.log(warning("  No supported AI tools detected."));
+    console.log(dim("  Supported: Claude Code, Claude Desktop, Cursor, Windsurf, GitHub Copilot, Amazon Q, Zed"));
     console.log();
     return;
   }
-  if (alreadyConnected.length > 0) {
-    console.log(dim(`  Already connected: ${alreadyConnected.join(", ")}`));
-    console.log();
+  const connectedCount = detected.filter((d) => d.connected).length;
+  const availableCount = detected.length - connectedCount;
+  if (connectedCount > 0 || availableCount > 0) {
+    const parts = [];
+    if (connectedCount > 0) parts.push(`${connectedCount} connected`);
+    if (availableCount > 0) parts.push(`${availableCount} available`);
+    console.log(dim(`  ${parts.join(", ")}`));
   }
-  const choices = unconfigured.map((u) => ({
-    name: u.tool.name,
-    value: u,
-    checked: true
+  console.log();
+  const choices = detected.map((d) => ({
+    name: `${d.tool.name}${d.connected ? dim(" (connected)") : ""}`,
+    value: d,
+    checked: d.connected
   }));
   const selected = await checkbox6({
-    message: "Select tools to connect:",
+    message: "Select tools to keep connected (toggle with space):",
     choices
   });
-  if (selected.length === 0) {
-    console.log(dim("  No tools selected."));
+  const toConnect = selected.filter((s) => !s.connected);
+  const toDisconnect = detected.filter((d) => d.connected && !selected.includes(d));
+  if (toConnect.length === 0 && toDisconnect.length === 0) {
+    console.log(dim("  No changes."));
+    console.log();
     return;
   }
   console.log();
-  for (const { tool, configPath } of selected) {
+  for (const { tool, configPath } of toConnect) {
     const serverConfig = tool.generateConfig(slug, apiKey);
     mergeConfig(configPath, tool.configKey, serverConfig);
     toolLine(tool.name, success("connected"), "\u2714");
   }
-  if (validation.serverUrl) {
+  const removedNames = [];
+  for (const { tool, configPath } of toDisconnect) {
+    const removed = removeFromConfig(configPath, tool.configKey);
+    if (removed) {
+      removedNames.push(tool.name);
+      toolLine(tool.name, warning("disconnected"), "\u2714");
+    }
+  }
+  if (toConnect.length > 0 && validation.serverUrl) {
     await Promise.all(
-      selected.map(({ tool }) => pingMcp(validation.serverUrl, apiKey, tool.name))
+      toConnect.map(({ tool }) => pingMcp(validation.serverUrl, apiKey, tool.name))
     );
   }
+  if (removedNames.length > 0) {
+    deleteConnections(apiKey, removedNames).catch(() => {
+    });
+  }
   console.log();
   console.log(dim("  Restart your AI tools for changes to take effect."));
   console.log();
 }
-async function handleDisconnectTools() {
-  const configured = [];
-  for (const tool of TOOLS) {
-    const paths = resolveConfigPaths(tool.configPaths);
-    for (const configPath of paths) {
-      if (fs12.existsSync(configPath) && isPiutConfigured(configPath, tool.configKey)) {
-        configured.push({ tool, configPath });
-        break;
-      }
-    }
-  }
-  if (configured.length === 0) {
-    console.log(dim("  p\u0131ut is not configured in any detected AI tools."));
+async function handleManageProjects(apiKey, validation) {
+  const { slug, serverUrl } = validation;
+  console.log(dim("  Scanning for projects..."));
+  const projects = scanForProjects();
+  if (projects.length === 0) {
+    console.log(warning("  No projects found."));
+    console.log(dim("  Try running from a directory with your projects."));
     console.log();
     return;
   }
-  const choices = configured.map((c) => ({
-    name: c.tool.name,
-    value: c
+  const items = projects.map((p) => ({
+    project: p,
+    connected: hasPiutDir(p.path)
+  }));
+  const connectedCount = items.filter((i) => i.connected).length;
+  const availableCount = items.length - connectedCount;
+  const parts = [];
+  if (connectedCount > 0) parts.push(`${connectedCount} connected`);
+  if (availableCount > 0) parts.push(`${availableCount} available`);
+  console.log(dim(`  ${parts.join(", ")}`));
+  console.log();
+  const choices = items.map((i) => ({
+    name: `${i.project.name}${i.connected ? dim(" (connected)") : ""}`,
+    value: i,
+    checked: i.connected
   }));
   const selected = await checkbox6({
-    message: "Select tools to disconnect:",
+    message: "Select projects to keep connected (toggle with space):",
     choices
   });
-  if (selected.length === 0) {
-    console.log(dim("  No tools selected."));
+  const toConnect = selected.filter((s) => !s.connected);
+  const toDisconnect = items.filter((i) => i.connected && !selected.includes(i));
+  if (toConnect.length === 0 && toDisconnect.length === 0) {
+    console.log(dim("  No changes."));
+    console.log();
     return;
   }
-  const proceed = await confirm7({
-    message: `Disconnect p\u0131ut from ${selected.length} tool(s)?`,
-    default: false
-  });
-  if (!proceed) return;
   console.log();
-  for (const { tool, configPath } of selected) {
-    const removed = removeFromConfig(configPath, tool.configKey);
-    if (removed) {
-      toolLine(tool.name, success("disconnected"), "\u2714");
-    } else {
-      toolLine(tool.name, warning("not found"), "\xD7");
+  const copilotTool = TOOLS.find((t) => t.id === "copilot");
+  for (const { project } of toConnect) {
+    const projectName = path15.basename(project.path);
+    writePiutConfig(project.path, { slug, apiKey, serverUrl });
+    await writePiutSkill(project.path, slug, apiKey);
+    ensureGitignored(project.path);
+    if (copilotTool) {
+      const hasCopilot = fs14.existsSync(path15.join(project.path, ".github", "copilot-instructions.md")) || fs14.existsSync(path15.join(project.path, ".github"));
+      if (hasCopilot) {
+        const vscodeMcpPath = path15.join(project.path, ".vscode", "mcp.json");
+        const serverConfig = copilotTool.generateConfig(slug, apiKey);
+        mergeConfig(vscodeMcpPath, copilotTool.configKey, serverConfig);
+      }
+    }
+    for (const rule of RULE_FILES) {
+      if (!rule.detect(project)) continue;
+      const absPath = path15.join(project.path, rule.filePath);
+      if (fs14.existsSync(absPath) && hasPiutReference2(absPath)) continue;
+      if (rule.strategy === "create" || !fs14.existsSync(absPath)) {
+        const isAppendType = rule.strategy === "append";
+        const content = isAppendType ? PROJECT_SKILL_SNIPPET + "\n" : DEDICATED_FILE_CONTENT;
+        fs14.mkdirSync(path15.dirname(absPath), { recursive: true });
+        fs14.writeFileSync(absPath, content, "utf-8");
+      } else {
+        fs14.appendFileSync(absPath, APPEND_SECTION);
+      }
+    }
+    toolLine(projectName, success("connected"), "\u2714");
+    const machineId = getMachineId();
+    const toolsDetected = RULE_FILES.filter((r) => r.detect(project)).map((r) => r.tool);
+    registerProject(apiKey, {
+      projectName,
+      projectPath: project.path,
+      machineId,
+      toolsDetected,
+      configFiles: RULE_FILES.filter((r) => r.detect(project)).map((r) => r.filePath)
+    }).catch(() => {
+    });
+  }
+  for (const { project } of toDisconnect) {
+    const projectName = path15.basename(project.path);
+    for (const dedicatedFile of DEDICATED_FILES) {
+      const absPath = path15.join(project.path, dedicatedFile);
+      if (fs14.existsSync(absPath) && hasPiutReference2(absPath)) {
+        try {
+          fs14.unlinkSync(absPath);
+        } catch {
+        }
+      }
+    }
+    for (const appendFile of APPEND_FILES) {
+      const absPath = path15.join(project.path, appendFile);
+      if (fs14.existsSync(absPath) && hasPiutReference2(absPath)) {
+        removePiutSection(absPath);
+      }
+    }
+    const vscodeMcpPath = path15.join(project.path, ".vscode", "mcp.json");
+    if (fs14.existsSync(vscodeMcpPath) && isPiutConfigured(vscodeMcpPath, "servers")) {
+      removeFromConfig(vscodeMcpPath, "servers");
     }
+    removePiutDir(project.path);
+    toolLine(projectName, warning("disconnected"), "\u2714");
+    const machineId = getMachineId();
+    unregisterProject(apiKey, project.path, machineId).catch(() => {
+    });
   }
   console.log();
-  console.log(dim("  Restart your AI tools for changes to take effect."));
+  if (toConnect.length > 0) {
+    console.log(success(`  ${toConnect.length} project(s) connected.`));
+  }
+  if (toDisconnect.length > 0) {
+    console.log(success(`  ${toDisconnect.length} project(s) disconnected.`));
+  }
+  console.log();
+}
+function handleEditBrain() {
+  console.log(dim("  Opening piut.com/dashboard..."));
+  openInBrowser("https://piut.com/dashboard");
+  console.log(success("  \u2713 Opened in browser."));
+  console.log();
+}
+function formatScanContent(input3) {
+  const { summary } = input3;
+  const parts = [];
+  parts.push("The user has re-scanned their filesystem. Below is updated information about their projects, config files, and documents. Please merge this into the existing brain sections, preserving existing content and updating what has changed.");
+  parts.push("");
+  if (summary.folders.length > 0) {
+    parts.push(`## Folder Structure
+${summary.folders.join("\n")}`);
+  }
+  if (summary.projects.length > 0) {
+    const projectLines = summary.projects.map(
+      (p) => `- **${p.name}** (${p.path})${p.description ? ` \u2014 ${p.description}` : ""}`
+    );
+    parts.push(`## Projects Found
+${projectLines.join("\n")}`);
+  }
+  const totalFiles = (summary.configFiles?.length || 0) + (summary.recentDocuments?.length || 0) + (summary.personalDocuments?.length || 0);
+  const fileLimit = totalFiles <= 10 ? 1e4 : totalFiles <= 30 ? 5e3 : totalFiles <= 60 ? 3e3 : 2e3;
+  if (summary.configFiles.length > 0) {
+    const configBlocks = summary.configFiles.map(
+      (f) => `### ${f.name}
+\`\`\`
+${f.content.slice(0, fileLimit)}
+\`\`\``
+    );
+    parts.push(`## AI Config Files
+${configBlocks.join("\n\n")}`);
+  }
+  if (summary.recentDocuments.length > 0) {
+    const docBlocks = summary.recentDocuments.map(
+      (f) => `### ${f.name}
+${f.content.slice(0, fileLimit)}`
+    );
+    parts.push(`## Recent Documents
+${docBlocks.join("\n\n")}`);
+  }
+  if (summary.personalDocuments && summary.personalDocuments.length > 0) {
+    const docBlocks = summary.personalDocuments.map(
+      (f) => `### ${f.name}
+${f.content.slice(0, fileLimit)}`
+    );
+    parts.push(`## Personal Documents
+${docBlocks.join("\n\n")}`);
+  }
+  let result = parts.join("\n\n");
+  if (result.length > 4e5) {
+    result = result.slice(0, 4e5);
+  }
+  return result;
+}
+async function handleResyncBrain(apiKey, validation) {
+  if (!validation.serverUrl) {
+    console.log(warning("  Brain must be deployed before resyncing."));
+    console.log(dim("  Run ") + brand("piut deploy") + dim(" first."));
+    console.log();
+    return;
+  }
+  const cwd = process.cwd();
+  const cwdDisplay = cwd.replace(os8.homedir(), "~");
+  console.log(dim(`  Scanning ${cwdDisplay}...`));
+  const scanResult = await scanFolders([cwd]);
+  const allFolderPaths = scanResult.folders.map((f) => f.path);
+  const brainInput = buildBrainInput(scanResult, allFolderPaths);
+  const projCount = brainInput.summary.projects.length;
+  const cfgCount = brainInput.summary.configFiles.length;
+  const dcCount = (brainInput.summary.personalDocuments?.length || 0) + brainInput.summary.recentDocuments.length;
+  console.log(success(`  Scanned: ${projCount} projects, ${cfgCount} config files, ${dcCount} docs`));
   console.log();
+  if (projCount === 0 && cfgCount === 0) {
+    console.log(chalk11.yellow("  No projects or config files found to resync from."));
+    console.log();
+    return;
+  }
+  const content = formatScanContent(brainInput);
+  const spinner = new Spinner();
+  spinner.start("Resyncing brain...");
+  try {
+    const result = await resyncBrain(validation.serverUrl, apiKey, content);
+    spinner.stop();
+    console.log();
+    console.log(success("  \u2713 Brain resynced."));
+    console.log(dim(`  ${result.summary}`));
+    console.log();
+  } catch (err) {
+    spinner.stop();
+    const msg = err.message;
+    console.log(chalk11.red(`  \u2717 ${msg}`));
+    console.log();
+    throw new CliError(msg);
+  }
 }
 async function handleViewBrain(apiKey) {
   console.log(dim("  Loading brain..."));
@@ -2795,11 +3592,11 @@ async function handleViewBrain(apiKey) {
         console.log();
         const msg = err.message;
         if (msg === "REQUIRES_SUBSCRIPTION") {
-          console.log(chalk10.yellow("  Deploy requires an active subscription ($10/mo)."));
+          console.log(chalk11.yellow("  Deploy requires an active subscription ($10/mo)."));
           console.log(`  Subscribe at: ${brand("https://piut.com/dashboard/billing")}`);
           console.log(dim("  14-day free trial included."));
         } else {
-          console.log(chalk10.red(`  \u2717 ${msg}`));
+          console.log(chalk11.red(`  \u2717 ${msg}`));
         }
         console.log();
       }
@@ -2808,7 +3605,7 @@ async function handleViewBrain(apiKey) {
 }
 
 // src/cli.ts
-var VERSION = "3.5.0";
+var VERSION = "3.6.0";
 function withExit(fn) {
   return async (...args2) => {
     try {
@@ -2831,6 +3628,7 @@ program.command("disconnect").description("Remove brain references from project
 program.command("setup").description("Auto-detect and configure AI tools (MCP config)").option("-k, --key <key>", "API key (prompts interactively if not provided)").option("-t, --tool <id>", "Configure a single tool (claude-code, cursor, windsurf, etc.)").option("-y, --yes", "Skip interactive prompts (auto-select all detected tools)").option("--project", "Prefer project-local config files").option("--skip-skill", "Skip skill.md file placement").action(withExit(setupCommand));
 program.command("status").description("Show brain, deployment, and connected projects").option("--verify", "Validate API key, check tool configs, and test MCP endpoint").action(withExit(statusCommand));
 program.command("remove").description("Remove all p\u0131ut configurations").action(withExit(removeCommand));
+program.command("login").description("Authenticate with p\u0131ut (email, browser, or API key)").action(withExit(loginCommand));
 program.command("logout").description("Remove saved API key").action(logoutCommand);
 program.command("doctor").description("Diagnose and fix connection issues").option("-k, --key <key>", "API key to verify against").option("--fix", "Auto-fix stale configurations").option("--json", "Output results as JSON").action(withExit(doctorCommand));
 program.command("update").description("Check for and install CLI updates").action(() => updateCommand(VERSION));