@8gi-foundation/8gent-code 0.11.0 → 0.11.12

package/dist/cli.js

@@ -493326,16 +493326,185 @@ class WorktreeMessaging {
 }
 var init_worktree_messaging = () => {};
 
+// packages/settings/defaults.ts
+var DEFAULT_SETTINGS;
+var init_defaults = __esm(() => {
+  DEFAULT_SETTINGS = {
+    version: 1,
+    voice: {
+      silenceThresholdMs: 2000,
+      bargeIn: true,
+      ttsVoice: "Ava",
+      outputEnabled: true,
+      perAgent: {
+        orchestrator: "Daniel",
+        engineer: "Karen",
+        qa: "Moira"
+      }
+    },
+    performance: {
+      mode: "auto",
+      introBanner: "auto"
+    },
+    models: {
+      tabs: {
+        orchestrator: { provider: "ollama", model: "qwen3.6:27b" },
+        engineer: { provider: "lmstudio", model: "google/gemma-4-26b-a4b" },
+        qa: { provider: "apfel", model: "apple-foundationmodel" }
+      }
+    },
+    providers: {
+      apfel: { baseURL: "http://localhost:11500/v1" },
+      ollama: { baseURL: "http://localhost:11434/v1" },
+      lmstudio: { baseURL: "http://localhost:1234/v1" },
+      openrouter: { baseURL: "https://openrouter.ai/api/v1" }
+    },
+    ui: {
+      theme: "amber",
+      thinkingVisualiser: {
+        enabled: true,
+        operatorRotationMs: 8000,
+        boredomThresholdMs: 30000
+      },
+      introSound: ""
+    },
+    agents: {
+      names: {
+        orchestrator: "Orchestrator",
+        engineer: "Engineer",
+        qa: "QA"
+      }
+    }
+  };
+});
+
+// packages/settings/store.ts
+import * as fs28 from "fs";
+import * as os19 from "os";
+import * as path29 from "path";
+function ensureDir3() {
+  try {
+    if (!fs28.existsSync(SETTINGS_DIR)) {
+      fs28.mkdirSync(SETTINGS_DIR, { recursive: true });
+    }
+  } catch {}
+}
+function deepMerge(defaults, user) {
+  if (user === null || user === undefined)
+    return defaults;
+  if (typeof defaults !== "object" || defaults === null) {
+    if (typeof user === typeof defaults)
+      return user;
+    return defaults;
+  }
+  if (Array.isArray(defaults)) {
+    return Array.isArray(user) ? user : defaults;
+  }
+  const out = { ...defaults };
+  if (typeof user === "object" && user !== null && !Array.isArray(user)) {
+    const u3 = user;
+    for (const key of Object.keys(out)) {
+      if (key in u3) {
+        out[key] = deepMerge(defaults[key], u3[key]);
+      }
+    }
+  }
+  return out;
+}
+function loadSettings() {
+  try {
+    if (!fs28.existsSync(SETTINGS_FILE)) {
+      return DEFAULT_SETTINGS;
+    }
+    const raw = fs28.readFileSync(SETTINGS_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    const merged = deepMerge(DEFAULT_SETTINGS, parsed);
+    return { ...merged, version: DEFAULT_SETTINGS.version };
+  } catch {
+    return DEFAULT_SETTINGS;
+  }
+}
+function saveSettings(s3) {
+  try {
+    ensureDir3();
+    fs28.writeFileSync(SETTINGS_FILE, `${JSON.stringify(s3, null, 2)}
+`, "utf-8");
+  } catch {}
+}
+var SETTINGS_DIR, SETTINGS_FILE;
+var init_store2 = __esm(() => {
+  init_defaults();
+  SETTINGS_DIR = path29.join(os19.homedir(), ".8gent");
+  SETTINGS_FILE = path29.join(SETTINGS_DIR, "settings.json");
+});
+
+// packages/settings/voice.ts
+var init_voice2 = __esm(() => {
+  init_defaults();
+  init_store2();
+});
+
+// packages/settings/agents.ts
+function isKnownRole(role) {
+  return KNOWN_ROLES.includes(role);
+}
+function capitalize(s3) {
+  if (!s3)
+    return s3;
+  return s3.charAt(0).toUpperCase() + s3.slice(1);
+}
+function resolveRoleName(role, settings) {
+  const s3 = settings ?? loadSettings();
+  if (isKnownRole(role)) {
+    const chosen = s3.agents?.names?.[role];
+    if (typeof chosen === "string" && chosen.trim().length > 0) {
+      return chosen.trim();
+    }
+    return DEFAULT_SETTINGS.agents.names[role];
+  }
+  return capitalize(role) || "Agent";
+}
+var KNOWN_ROLES;
+var init_agents = __esm(() => {
+  init_defaults();
+  init_store2();
+  KNOWN_ROLES = ["orchestrator", "engineer", "qa"];
+});
+
+// packages/settings/index.ts
+var init_settings = __esm(() => {
+  init_voice2();
+  init_agents();
+  init_defaults();
+  init_store2();
+});
+
 // packages/orchestration/role-registry.ts
+function buildSystemPrompt(role) {
+  const template = ROLE_PROMPT_TEMPLATES[role] ?? ROLE_PROMPT_TEMPLATES.engineer;
+  return template.replace("{name}", resolveRoleName(role));
+}
 function getRunnerConfig(role) {
-  return ROLE_REGISTRY[role] ?? ROLE_REGISTRY.engineer;
+  const cfg = ROLE_REGISTRY[role] ?? ROLE_REGISTRY.engineer;
+  return {
+    ...cfg,
+    systemPrompt: cfg.systemPrompt
+  };
 }
-var ROLE_REGISTRY;
+var ROLE_PROMPT_TEMPLATES, ROLE_REGISTRY;
 var init_role_registry = __esm(() => {
+  init_settings();
+  ROLE_PROMPT_TEMPLATES = {
+    orchestrator: "You are {name}. Plan, delegate, and coordinate. Think before acting. No code - direct others.",
+    engineer: "You are {name}. Write code, edit files, run commands. Implement exactly what is asked. No fluff.",
+    qa: "You are {name}. Find bugs, review diffs, run tests. Be harsh. Reject anything that doesn't meet the spec."
+  };
   ROLE_REGISTRY = {
     orchestrator: {
       role: "orchestrator",
-      systemPrompt: "You are the Orchestrator. Plan, delegate, and coordinate. Think before acting. No code \u2014 direct others.",
+      get systemPrompt() {
+        return buildSystemPrompt("orchestrator");
+      },
       allowedTools: ["write_notes", "gh_issue_create", "gh_pr_list", "gh_issue_list"],
       retryPolicy: { maxAttempts: 2, backoffMs: 1000 },
       inferenceMode: "ollama",
@@ -493343,7 +493512,9 @@ var init_role_registry = __esm(() => {
     },
     engineer: {
       role: "engineer",
-      systemPrompt: "You are the Engineer. Write code, edit files, run commands. Implement exactly what is asked. No fluff.",
+      get systemPrompt() {
+        return buildSystemPrompt("engineer");
+      },
       allowedTools: [
         "read_file",
         "write_file",
@@ -493367,7 +493538,9 @@ var init_role_registry = __esm(() => {
     },
     qa: {
       role: "qa",
-      systemPrompt: "You are QA. Find bugs, review diffs, run tests. Be harsh. Reject anything that doesn't meet the spec.",
+      get systemPrompt() {
+        return buildSystemPrompt("qa");
+      },
       allowedTools: [
         "read_file",
         "list_files",
@@ -494580,12 +494753,12 @@ function createApi(pathParts = []) {
           const found = ["api", ...pathParts].join(".");
           throw new Error(`API path is expected to be of the form \`api.moduleName.functionName\`. Found: \`${found}\``);
         }
-        const path29 = pathParts.slice(0, -1).join("/");
+        const path30 = pathParts.slice(0, -1).join("/");
         const exportName = pathParts[pathParts.length - 1];
         if (exportName === "default") {
-          return path29;
+          return path30;
         } else {
-          return path29 + ":" + exportName;
+          return path30 + ":" + exportName;
         }
       } else if (prop2 === Symbol.toStringTag) {
         return "FunctionReference";
@@ -497078,16 +497251,16 @@ var init_simple_client_node = __esm(() => {
   });
   require_node_gyp_build = __commonJS2({
     "../common/temp/node_modules/.pnpm/node-gyp-build@4.8.4/node_modules/node-gyp-build/node-gyp-build.js"(exports, module) {
-      var fs28 = __require2("fs");
-      var path29 = __require2("path");
-      var os19 = __require2("os");
+      var fs29 = __require2("fs");
+      var path30 = __require2("path");
+      var os20 = __require2("os");
       var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require2;
       var vars = process.config && process.config.variables || {};
       var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
       var abi = process.versions.modules;
       var runtime = isElectron() ? "electron" : isNwjs() ? "node-webkit" : "node";
-      var arch = process.env.npm_config_arch || os19.arch();
-      var platform4 = process.env.npm_config_platform || os19.platform();
+      var arch = process.env.npm_config_arch || os20.arch();
+      var platform4 = process.env.npm_config_platform || os20.platform();
       var libc = process.env.LIBC || (isAlpine(platform4) ? "musl" : "glibc");
       var armv = process.env.ARM_VERSION || (arch === "arm64" ? "8" : vars.arm_version) || "";
       var uv = (process.versions.uv || "").split(".")[0];
@@ -497096,24 +497269,24 @@ var init_simple_client_node = __esm(() => {
         return runtimeRequire(load2.resolve(dir));
       }
       load2.resolve = load2.path = function(dir) {
-        dir = path29.resolve(dir || ".");
+        dir = path30.resolve(dir || ".");
         try {
-          var name21 = runtimeRequire(path29.join(dir, "package.json")).name.toUpperCase().replace(/-/g, "_");
+          var name21 = runtimeRequire(path30.join(dir, "package.json")).name.toUpperCase().replace(/-/g, "_");
           if (process.env[name21 + "_PREBUILD"])
             dir = process.env[name21 + "_PREBUILD"];
         } catch (err) {}
         if (!prebuildsOnly) {
-          var release3 = getFirst(path29.join(dir, "build/Release"), matchBuild);
+          var release3 = getFirst(path30.join(dir, "build/Release"), matchBuild);
           if (release3)
             return release3;
-          var debug = getFirst(path29.join(dir, "build/Debug"), matchBuild);
+          var debug = getFirst(path30.join(dir, "build/Debug"), matchBuild);
           if (debug)
             return debug;
         }
         var prebuild = resolve9(dir);
         if (prebuild)
           return prebuild;
-        var nearby = resolve9(path29.dirname(process.execPath));
+        var nearby = resolve9(path30.dirname(process.execPath));
         if (nearby)
           return nearby;
         var target = [
@@ -497132,28 +497305,28 @@ var init_simple_client_node = __esm(() => {
     loaded from: ` + dir + `
 `);
         function resolve9(dir2) {
-          var tuples = readdirSync7(path29.join(dir2, "prebuilds")).map(parseTuple);
+          var tuples = readdirSync7(path30.join(dir2, "prebuilds")).map(parseTuple);
           var tuple2 = tuples.filter(matchTuple(platform4, arch)).sort(compareTuples)[0];
           if (!tuple2)
             return;
-          var prebuilds = path29.join(dir2, "prebuilds", tuple2.name);
+          var prebuilds = path30.join(dir2, "prebuilds", tuple2.name);
           var parsed = readdirSync7(prebuilds).map(parseTags);
           var candidates = parsed.filter(matchTags(runtime, abi));
           var winner = candidates.sort(compareTags(runtime))[0];
           if (winner)
-            return path29.join(prebuilds, winner.file);
+            return path30.join(prebuilds, winner.file);
         }
       };
       function readdirSync7(dir) {
         try {
-          return fs28.readdirSync(dir);
+          return fs29.readdirSync(dir);
         } catch (err) {
           return [];
         }
       }
       function getFirst(dir, filter5) {
         var files = readdirSync7(dir).filter(filter5);
-        return files[0] && path29.join(dir, files[0]);
+        return files[0] && path30.join(dir, files[0]);
       }
       function matchBuild(name21) {
         return /\.node$/.test(name21);
@@ -497255,7 +497428,7 @@ var init_simple_client_node = __esm(() => {
         return typeof window !== "undefined" && window.process && window.process.type === "renderer";
       }
       function isAlpine(platform22) {
-        return platform22 === "linux" && fs28.existsSync("/etc/alpine-release");
+        return platform22 === "linux" && fs29.existsSync("/etc/alpine-release");
       }
       load2.parseTags = parseTags;
       load2.matchTags = matchTags;
@@ -501494,16 +501667,16 @@ var init_orchestration = __esm(() => {
 });
 
 // packages/eight/tools.ts
-import * as fs28 from "fs";
-import * as path29 from "path";
+import * as fs29 from "fs";
+import * as path30 from "path";
 function safePath(userPath, workingDirectory) {
-  const normalized2 = path29.normalize(userPath);
-  const absolutePath = path29.isAbsolute(normalized2) ? path29.resolve(normalized2) : path29.resolve(workingDirectory, normalized2);
-  const normalizedBase = path29.resolve(workingDirectory);
-  const normalizedTarget = path29.resolve(absolutePath);
+  const normalized2 = path30.normalize(userPath);
+  const absolutePath = path30.isAbsolute(normalized2) ? path30.resolve(normalized2) : path30.resolve(workingDirectory, normalized2);
+  const normalizedBase = path30.resolve(workingDirectory);
+  const normalizedTarget = path30.resolve(absolutePath);
   if (normalizedTarget === normalizedBase)
     return normalizedTarget;
-  if (!normalizedTarget.startsWith(normalizedBase + path29.sep)) {
+  if (!normalizedTarget.startsWith(normalizedBase + path30.sep)) {
     throw new Error(`Path traversal blocked: "${userPath}" resolves outside working directory`);
   }
   return normalizedTarget;
@@ -502516,8 +502689,8 @@ var init_tools = __esm(() => {
       }
     }
     async getOutline(filePath) {
-      const absolutePath = path29.isAbsolute(filePath) ? filePath : path29.join(this.workingDirectory, filePath);
-      if (!fs28.existsSync(absolutePath)) {
+      const absolutePath = path30.isAbsolute(filePath) ? filePath : path30.join(this.workingDirectory, filePath);
+      if (!fs29.existsSync(absolutePath)) {
         return `File not found: ${absolutePath}`;
       }
       try {
@@ -502545,8 +502718,8 @@ var init_tools = __esm(() => {
       }
       const filePath = symbolId.slice(0, separatorIndex);
       const symbolName = symbolId.slice(separatorIndex + 2);
-      const absolutePath = path29.isAbsolute(filePath) ? filePath : path29.join(this.workingDirectory, filePath);
-      if (!fs28.existsSync(absolutePath)) {
+      const absolutePath = path30.isAbsolute(filePath) ? filePath : path30.join(this.workingDirectory, filePath);
+      if (!fs29.existsSync(absolutePath)) {
         return `File not found: ${absolutePath}`;
       }
       try {
@@ -502583,7 +502756,7 @@ ${source}`;
               matches.push({
                 name: symbol21.name,
                 kind: symbol21.kind,
-                file: path29.relative(this.workingDirectory, file2),
+                file: path30.relative(this.workingDirectory, file2),
                 line: symbol21.startLine
               });
             }
@@ -502634,11 +502807,11 @@ ${source}`;
 `);
     }
     async readFile(filePath) {
-      const absolutePath = path29.isAbsolute(filePath) ? filePath : path29.join(this.workingDirectory, filePath);
-      if (!fs28.existsSync(absolutePath)) {
+      const absolutePath = path30.isAbsolute(filePath) ? filePath : path30.join(this.workingDirectory, filePath);
+      if (!fs29.existsSync(absolutePath)) {
         return `File not found: ${absolutePath}`;
       }
-      const content = fs28.readFileSync(absolutePath, "utf-8");
+      const content = fs29.readFileSync(absolutePath, "utf-8");
       const lines = content.split(`
 `);
       const isCodeFile = /\.(ts|tsx|js|jsx)$/.test(absolutePath);
@@ -502653,7 +502826,7 @@ ${source}`;
           } catch {}
         }
         if (this.astIndexReady && this.astRepoId) {
-          const relativePath = path29.relative(this.workingDirectory, absolutePath);
+          const relativePath = path30.relative(this.workingDirectory, absolutePath);
           const outline = getFileOutline(this.astRepoId, relativePath);
           if (outline && outline.symbols.length > 0) {
             const symbolList = outline.symbols.map((s3) => `  ${s3.kind} ${s3.name} (L${s3.startLine}-${s3.endLine})`).join(`
@@ -502694,15 +502867,15 @@ ${lines.slice(0, 200).join(`
       return content;
     }
     async writeFile(filePath, content) {
-      const absolutePath = path29.isAbsolute(filePath) ? filePath : path29.join(this.workingDirectory, filePath);
+      const absolutePath = path30.isAbsolute(filePath) ? filePath : path30.join(this.workingDirectory, filePath);
       const uiExtensions = [".tsx", ".jsx", ".css", ".html", ".svelte", ".vue"];
-      const ext = path29.extname(absolutePath).toLowerCase();
+      const ext = path30.extname(absolutePath).toLowerCase();
       let designHint = "";
       if (uiExtensions.includes(ext)) {
         try {
-          const isNewFile = !fs28.existsSync(absolutePath);
-          if (isNewFile && needsDesignDecision(`create UI file ${path29.basename(absolutePath)}`)) {
-            const detection = await detectDesignNeed(`create UI component: ${path29.basename(absolutePath)}`);
+          const isNewFile = !fs29.existsSync(absolutePath);
+          if (isNewFile && needsDesignDecision(`create UI file ${path30.basename(absolutePath)}`)) {
+            const detection = await detectDesignNeed(`create UI component: ${path30.basename(absolutePath)}`);
             if (detection.needsDesign) {
               designHint = `
 [Design Agent] This is a new UI file. Consider using suggest_design or query_design_system to ensure consistent design. Detected: ${detection.reason}`;
@@ -502710,11 +502883,11 @@ ${lines.slice(0, 200).join(`
           }
         } catch {}
       }
-      const dir = path29.dirname(absolutePath);
-      if (!fs28.existsSync(dir)) {
-        fs28.mkdirSync(dir, { recursive: true });
+      const dir = path30.dirname(absolutePath);
+      if (!fs29.existsSync(dir)) {
+        fs29.mkdirSync(dir, { recursive: true });
       }
-      fs28.writeFileSync(absolutePath, content);
+      fs29.writeFileSync(absolutePath, content);
       if (process.platform === "darwin") {
         try {
           const { spawn: spawn10 } = await import("child_process");
@@ -502727,22 +502900,22 @@ ${lines.slice(0, 200).join(`
       return `File written and opened: ${absolutePath}${designHint}`;
     }
     async editFile(filePath, oldText, newText) {
-      const absolutePath = path29.isAbsolute(filePath) ? filePath : path29.join(this.workingDirectory, filePath);
-      if (!fs28.existsSync(absolutePath)) {
+      const absolutePath = path30.isAbsolute(filePath) ? filePath : path30.join(this.workingDirectory, filePath);
+      if (!fs29.existsSync(absolutePath)) {
         return `File not found: ${absolutePath}`;
       }
-      const content = fs28.readFileSync(absolutePath, "utf-8");
+      const content = fs29.readFileSync(absolutePath, "utf-8");
       if (!content.includes(oldText)) {
         return `Error: Could not find the text to replace in ${filePath}. Make sure oldText matches exactly.`;
       }
       const newContent = content.replace(oldText, newText);
-      fs28.writeFileSync(absolutePath, newContent);
+      fs29.writeFileSync(absolutePath, newContent);
       return `File edited: ${absolutePath}
 Replaced ${oldText.length} chars with ${newText.length} chars.`;
     }
     async listFiles(dirPath = ".", pattern) {
       const { glob } = await Promise.resolve().then(() => (init_index_min2(), exports_index_min));
-      const absolutePath = path29.isAbsolute(dirPath) ? dirPath : path29.join(this.workingDirectory, dirPath);
+      const absolutePath = path30.isAbsolute(dirPath) ? dirPath : path30.join(this.workingDirectory, dirPath);
       const files = await glob(pattern || "**/*", {
         cwd: absolutePath,
         ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"],
@@ -502880,7 +503053,7 @@ ${stderr}`);
       });
     }
     async handleReadImage(imagePath) {
-      const absolutePath = path29.isAbsolute(imagePath) ? imagePath : path29.join(this.workingDirectory, imagePath);
+      const absolutePath = path30.isAbsolute(imagePath) ? imagePath : path30.join(this.workingDirectory, imagePath);
       try {
         const imageInfo = await readImage(absolutePath);
         return JSON.stringify({
@@ -502899,7 +503072,7 @@ ${stderr}`);
       }
     }
     async handleDescribeImage(imagePath, prompt) {
-      const absolutePath = path29.isAbsolute(imagePath) ? imagePath : path29.join(this.workingDirectory, imagePath);
+      const absolutePath = path30.isAbsolute(imagePath) ? imagePath : path30.join(this.workingDirectory, imagePath);
       try {
         const description = await describeImage(absolutePath, prompt || "Describe this image in detail.", "llava");
         return JSON.stringify({
@@ -502915,7 +503088,7 @@ ${stderr}`);
       }
     }
     async handleReadPdf(pdfPath) {
-      const absolutePath = path29.isAbsolute(pdfPath) ? pdfPath : path29.join(this.workingDirectory, pdfPath);
+      const absolutePath = path30.isAbsolute(pdfPath) ? pdfPath : path30.join(this.workingDirectory, pdfPath);
       try {
         const pdfInfo = await readPdf(absolutePath);
         const maxTextLength = 1e4;
@@ -502934,7 +503107,7 @@ ${stderr}`);
       }
     }
     async handleReadPdfPage(pdfPath, pageNum) {
-      const absolutePath = path29.isAbsolute(pdfPath) ? pdfPath : path29.join(this.workingDirectory, pdfPath);
+      const absolutePath = path30.isAbsolute(pdfPath) ? pdfPath : path30.join(this.workingDirectory, pdfPath);
       try {
         const pageContent = await readPdfPage(absolutePath, pageNum);
         return JSON.stringify({
@@ -502948,7 +503121,7 @@ ${stderr}`);
       }
     }
     async handleSearchPdf(pdfPath, query, caseSensitive) {
-      const absolutePath = path29.isAbsolute(pdfPath) ? pdfPath : path29.join(this.workingDirectory, pdfPath);
+      const absolutePath = path30.isAbsolute(pdfPath) ? pdfPath : path30.join(this.workingDirectory, pdfPath);
       try {
         const results = await searchPdf(absolutePath, query, caseSensitive ?? false);
         return JSON.stringify({
@@ -502962,7 +503135,7 @@ ${stderr}`);
       }
     }
     async handleReadNotebook(notebookPath) {
-      const absolutePath = path29.isAbsolute(notebookPath) ? notebookPath : path29.join(this.workingDirectory, notebookPath);
+      const absolutePath = path30.isAbsolute(notebookPath) ? notebookPath : path30.join(this.workingDirectory, notebookPath);
       try {
         const notebook = await readNotebook(absolutePath);
         const formattedCells = notebook.cells.map((cell) => ({
@@ -502989,7 +503162,7 @@ ${stderr}`);
       }
     }
     async handleNotebookEditCell(notebookPath, cellIndex, newSource) {
-      const absolutePath = path29.isAbsolute(notebookPath) ? notebookPath : path29.join(this.workingDirectory, notebookPath);
+      const absolutePath = path30.isAbsolute(notebookPath) ? notebookPath : path30.join(this.workingDirectory, notebookPath);
       try {
         const result = await editCell(absolutePath, cellIndex, newSource);
         return JSON.stringify(result, null, 2);
@@ -502998,7 +503171,7 @@ ${stderr}`);
       }
     }
     async handleNotebookInsertCell(notebookPath, afterIndex, cellType, source) {
-      const absolutePath = path29.isAbsolute(notebookPath) ? notebookPath : path29.join(this.workingDirectory, notebookPath);
+      const absolutePath = path30.isAbsolute(notebookPath) ? notebookPath : path30.join(this.workingDirectory, notebookPath);
       try {
         const result = await insertCell(absolutePath, afterIndex, cellType, source);
         return JSON.stringify(result, null, 2);
@@ -503007,7 +503180,7 @@ ${stderr}`);
       }
     }
     async handleNotebookDeleteCell(notebookPath, cellIndex) {
-      const absolutePath = path29.isAbsolute(notebookPath) ? notebookPath : path29.join(this.workingDirectory, notebookPath);
+      const absolutePath = path30.isAbsolute(notebookPath) ? notebookPath : path30.join(this.workingDirectory, notebookPath);
       try {
         const result = await deleteCell(absolutePath, cellIndex);
         return JSON.stringify(result, null, 2);
@@ -503688,24 +503861,24 @@ ${list.map((a5, i4) => `${i4 + 1}. ${a5}`).join(`
 });
 
 // packages/reporting/runlog.ts
-import * as fs29 from "fs";
-import * as os19 from "os";
-import * as path30 from "path";
-function ensureDir3() {
-  const dir = path30.dirname(LOG_PATH);
-  if (!fs29.existsSync(dir)) {
-    fs29.mkdirSync(dir, { recursive: true });
+import * as fs30 from "fs";
+import * as os20 from "os";
+import * as path31 from "path";
+function ensureDir4() {
+  const dir = path31.dirname(LOG_PATH);
+  if (!fs30.existsSync(dir)) {
+    fs30.mkdirSync(dir, { recursive: true });
   }
 }
 function appendRun(entry) {
-  ensureDir3();
-  fs29.appendFileSync(LOG_PATH, `${JSON.stringify(entry)}
+  ensureDir4();
+  fs30.appendFileSync(LOG_PATH, `${JSON.stringify(entry)}
 `);
 }
 function readRuns(limit = 20) {
-  if (!fs29.existsSync(LOG_PATH))
+  if (!fs30.existsSync(LOG_PATH))
     return [];
-  const lines = fs29.readFileSync(LOG_PATH, "utf-8").trim().split(`
+  const lines = fs30.readFileSync(LOG_PATH, "utf-8").trim().split(`
 `).filter(Boolean);
   const entries = [];
   for (let i4 = lines.length - 1;i4 >= 0 && entries.length < limit; i4--) {
@@ -503717,15 +503890,15 @@ function readRuns(limit = 20) {
 }
 var LOG_PATH;
 var init_runlog = __esm(() => {
-  LOG_PATH = path30.join(os19.homedir(), ".8gent", "runs.jsonl");
+  LOG_PATH = path31.join(os20.homedir(), ".8gent", "runs.jsonl");
 });
 // packages/secrets/index.ts
 import * as crypto5 from "crypto";
-import * as fs30 from "fs";
-import * as os20 from "os";
-import * as path31 from "path";
+import * as fs31 from "fs";
+import * as os21 from "os";
+import * as path32 from "path";
 function deriveKey() {
-  const fingerprint = `${os20.hostname()}:${os20.userInfo().username}`;
+  const fingerprint = `${os21.hostname()}:${os21.userInfo().username}`;
   const salt = "8gent-vault-v1";
   return crypto5.pbkdf2Sync(fingerprint, salt, 1e5, 32, "sha256");
 }
@@ -503735,7 +503908,7 @@ class SecretVault {
   key;
   data;
   constructor(vaultPath) {
-    this.vaultPath = vaultPath ?? path31.join(os20.homedir(), ".8gent", "vault.enc");
+    this.vaultPath = vaultPath ?? path32.join(os21.homedir(), ".8gent", "vault.enc");
     this.key = deriveKey();
     this.data = this.load();
   }
@@ -503787,10 +503960,10 @@ class SecretVault {
     return callback(value);
   }
   migrateFromEnv(envPath) {
-    if (!fs30.existsSync(envPath)) {
+    if (!fs31.existsSync(envPath)) {
       throw new Error(`File not found: ${envPath}`);
     }
-    const content = fs30.readFileSync(envPath, "utf-8");
+    const content = fs31.readFileSync(envPath, "utf-8");
     const imported = [];
     const skipped = [];
     for (const line of content.split(`
@@ -503818,11 +503991,11 @@ class SecretVault {
     return { imported, skipped };
   }
   load() {
-    if (!fs30.existsSync(this.vaultPath)) {
+    if (!fs31.existsSync(this.vaultPath)) {
       return { version: 1, entries: {} };
     }
     try {
-      const raw = fs30.readFileSync(this.vaultPath, "utf-8");
+      const raw = fs31.readFileSync(this.vaultPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.version !== 1) {
         throw new Error(`Unsupported vault version: ${parsed.version}`);
@@ -503833,11 +504006,11 @@ class SecretVault {
     }
   }
   save() {
-    const dir = path31.dirname(this.vaultPath);
-    if (!fs30.existsSync(dir)) {
-      fs30.mkdirSync(dir, { recursive: true });
+    const dir = path32.dirname(this.vaultPath);
+    if (!fs31.existsSync(dir)) {
+      fs31.mkdirSync(dir, { recursive: true });
     }
-    fs30.writeFileSync(this.vaultPath, JSON.stringify(this.data, null, 2), { mode: 384 });
+    fs31.writeFileSync(this.vaultPath, JSON.stringify(this.data, null, 2), { mode: 384 });
   }
 }
 function getVault() {
@@ -503858,20 +504031,20 @@ __export(exports_telegram, {
   getActiveTelegramBot: () => getActiveTelegramBot,
   TelegramBot: () => TelegramBot
 });
-import * as fs31 from "fs";
-import * as os21 from "os";
-import * as path32 from "path";
+import * as fs32 from "fs";
+import * as os22 from "os";
+import * as path33 from "path";
 function loadConfig2() {
   try {
-    if (fs31.existsSync(CONFIG_FILE)) {
-      return JSON.parse(fs31.readFileSync(CONFIG_FILE, "utf-8"));
+    if (fs32.existsSync(CONFIG_FILE)) {
+      return JSON.parse(fs32.readFileSync(CONFIG_FILE, "utf-8"));
     }
   } catch {}
   return null;
 }
 function saveConfig(config2) {
-  fs31.mkdirSync(CONFIG_DIR, { recursive: true });
-  fs31.writeFileSync(CONFIG_FILE, JSON.stringify(config2, null, 2));
+  fs32.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs32.writeFileSync(CONFIG_FILE, JSON.stringify(config2, null, 2));
 }
 async function api3(token, method, body) {
   const url2 = `${API_BASE}${token}/${method}`;
@@ -504081,9 +504254,9 @@ ${taskLines}`;
 function buildSkillsMenu(agent) {
   let skillLines = "No skills loaded.";
   try {
-    const indexPath = path32.join(os21.homedir(), ".8gent", "skills", ".index.json");
-    if (fs31.existsSync(indexPath)) {
-      const index2 = JSON.parse(fs31.readFileSync(indexPath, "utf-8"));
+    const indexPath = path33.join(os22.homedir(), ".8gent", "skills", ".index.json");
+    if (fs32.existsSync(indexPath)) {
+      const index2 = JSON.parse(fs32.readFileSync(indexPath, "utf-8"));
       const cats = Object.entries(index2.categories || {}).sort((a5, b2) => b2[1] - a5[1]).map(([cat, count]) => `  ${cat}: ${count}`).join(`
 `);
       skillLines = `*${index2.skillCount}* skills loaded (${Math.round(index2.totalTokens / 1000)}k tokens)
@@ -504218,9 +504391,9 @@ class TelegramBot {
 
 No benchmark data found.`;
       try {
-        const statePath = path32.join(os21.homedir(), "iris-observatory", "benchmarks", "autoresearch", "loop-state.json");
-        if (fs31.existsSync(statePath)) {
-          const state = JSON.parse(fs31.readFileSync(statePath, "utf-8"));
+        const statePath = path33.join(os22.homedir(), "iris-observatory", "benchmarks", "autoresearch", "loop-state.json");
+        if (fs32.existsSync(statePath)) {
+          const state = JSON.parse(fs32.readFileSync(statePath, "utf-8"));
           const lastHistory = state.history?.[state.history.length - 1];
           if (lastHistory) {
             const scores = Object.entries(lastHistory.scores || {}).map(([id2, score]) => {
@@ -504492,8 +504665,8 @@ async function validateToken(token) {
 }
 var CONFIG_DIR, CONFIG_FILE, API_BASE = "https://api.telegram.org/bot", activeBotInstance = null;
 var init_telegram = __esm(() => {
-  CONFIG_DIR = path32.join(os21.homedir(), ".8gent");
-  CONFIG_FILE = path32.join(CONFIG_DIR, "telegram.json");
+  CONFIG_DIR = path33.join(os22.homedir(), ".8gent");
+  CONFIG_FILE = path33.join(CONFIG_DIR, "telegram.json");
 });
 
 // packages/self-autonomy/onboarding.ts
@@ -504501,19 +504674,39 @@ var exports_onboarding = {};
 __export(exports_onboarding, {
   runTelegramSetup: () => runTelegramSetup,
   default: () => onboarding_default,
+  PROVIDER_INSTALL_HINTS: () => PROVIDER_INSTALL_HINTS,
   OnboardingManager: () => OnboardingManager
 });
 import { exec as exec3 } from "child_process";
-import * as fs32 from "fs";
-import * as os22 from "os";
-import * as path33 from "path";
+import * as fs33 from "fs";
+import * as os23 from "os";
+import * as path34 from "path";
 import { promisify as promisify2 } from "util";
+function persistAgentName(roleKey, name21) {
+  const trimmed = (name21 ?? "").trim();
+  if (!trimmed)
+    return;
+  try {
+    const current = loadSettings();
+    const next2 = {
+      ...current,
+      agents: {
+        ...current.agents,
+        names: {
+          ...current.agents.names,
+          [roleKey]: trimmed
+        }
+      }
+    };
+    saveSettings(next2);
+  } catch {}
+}
 
 class OnboardingManager {
   userConfigPath;
   user;
   constructor(workingDirectory = process.cwd()) {
-    this.userConfigPath = path33.join(process.env.HOME || os22.homedir(), ".8gent", "user.json");
+    this.userConfigPath = path34.join(process.env.HOME || os23.homedir(), ".8gent", "user.json");
     this.user = this.loadUserConfig();
   }
   static async autoDetect() {
@@ -504580,19 +504773,19 @@ class OnboardingManager {
   }
   loadUserConfig() {
     try {
-      if (fs32.existsSync(this.userConfigPath)) {
-        const content = fs32.readFileSync(this.userConfigPath, "utf-8");
+      if (fs33.existsSync(this.userConfigPath)) {
+        const content = fs33.readFileSync(this.userConfigPath, "utf-8");
         return JSON.parse(content);
       }
     } catch {}
     return getDefaultUserConfig();
   }
   saveUserConfig() {
-    const dir = path33.dirname(this.userConfigPath);
-    if (!fs32.existsSync(dir)) {
-      fs32.mkdirSync(dir, { recursive: true });
+    const dir = path34.dirname(this.userConfigPath);
+    if (!fs33.existsSync(dir)) {
+      fs33.mkdirSync(dir, { recursive: true });
     }
-    fs32.writeFileSync(this.userConfigPath, JSON.stringify(this.user, null, 2));
+    fs33.writeFileSync(this.userConfigPath, JSON.stringify(this.user, null, 2));
   }
   needsOnboarding() {
     return !this.user.onboardingComplete;
@@ -504610,6 +504803,9 @@ class OnboardingManager {
     }
     return false;
   }
+  getTotalSteps() {
+    return ONBOARDING_QUESTIONS.length;
+  }
   getNextQuestion() {
     if (this.user.onboardingComplete) {
       return null;
@@ -504777,6 +504973,17 @@ class OnboardingManager {
     text4 = text4.replace("{detected_provider}", this.user.preferences.model.provider || "not detected");
     text4 = text4.replace("{detected_models}", this.user.integrations.ollama.models.slice(0, 3).join(", ") || "none found");
     text4 = text4.replace("{agent_name}", this.user.preferences.voice?.agentName || "Eight");
+    try {
+      const s3 = loadSettings();
+      const names = s3?.agents?.names ?? DEFAULT_SETTINGS.agents.names;
+      text4 = text4.replace("{agent_orchestrator}", names.orchestrator);
+      text4 = text4.replace("{agent_engineer}", names.engineer);
+      text4 = text4.replace("{agent_qa}", names.qa);
+    } catch {
+      text4 = text4.replace("{agent_orchestrator}", DEFAULT_SETTINGS.agents.names.orchestrator);
+      text4 = text4.replace("{agent_engineer}", DEFAULT_SETTINGS.agents.names.engineer);
+      text4 = text4.replace("{agent_qa}", DEFAULT_SETTINGS.agents.names.qa);
+    }
     return { ...question, question: text4 };
   }
 }
@@ -504920,63 +505127,123 @@ Use \x1B[36m/telegram start\x1B[0m to launch the bot, or it will auto-start next
 `);
   return true;
 }
-var execAsync2, ONBOARDING_QUESTIONS, onboarding_default;
+var execAsync2, PROVIDER_INSTALL_HINTS, ONBOARDING_QUESTIONS, onboarding_default;
 var init_onboarding = __esm(() => {
   init_secrets();
+  init_settings();
   execAsync2 = promisify2(exec3);
+  PROVIDER_INSTALL_HINTS = {
+    ollama: "Install: https://ollama.ai (or `brew install ollama && ollama serve`). Then `ollama pull qwen3.6:27b`.",
+    lmstudio: "Install: https://lmstudio.ai. Open it, load `google/gemma-4-26b-a4b`, click Start Server (port 1234).",
+    apfel: "Install: `brew install arthur-ficial/tap/apfel`. Run: `apfel --serve --port 11500`."
+  };
   ONBOARDING_QUESTIONS = [
     {
-      step: "identity",
+      step: "language",
       question: `Good day. I'm 8gent, The Infinite Gentleman.
 
-` + `Here's what I detected:
+` + `Here's what I detected from your environment:
 ` + `  Name: {detected_name}
 ` + `  Email: {detected_email}
 ` + `  GitHub: {detected_github}
 ` + `  Provider: {detected_provider}
 ` + `  Models: {detected_models}
 
-` + "Press Enter to accept, or type your preferred name:",
+` + "I'll walk you through a short setup so I can serve you properly.",
+      kind: "select",
+      choices: [{ label: "Press Enter to begin", value: "ok" }],
+      options: ["ok", "yes", "y"],
+      processor: (_answer, user) => ({
+        ...user,
+        completedSteps: [...user.completedSteps, "language"]
+      })
+    },
+    {
+      step: "identity",
+      question: "What should I call you? (default: {detected_name})",
       processor: (answer, user) => {
         const name21 = answer.trim() || user.identity.name;
         return {
           ...user,
           identity: { ...user.identity, name: name21 || user.identity.name },
-          completedSteps: [
-            ...user.completedSteps,
-            "identity",
-            "role",
-            "projects",
-            "model",
-            "language",
-            "telegram",
-            "github",
-            "mcps"
-          ]
+          completedSteps: [...user.completedSteps, "identity"]
+        };
+      }
+    },
+    {
+      step: "role",
+      question: "What best describes you?",
+      kind: "select",
+      choices: [
+        { label: "Engineer", value: "engineer", description: "Builder of software" },
+        { label: "Designer", value: "designer", description: "Crafter of interfaces" },
+        { label: "Founder", value: "founder", description: "Wearer of many hats" },
+        { label: "Hobbyist", value: "hobbyist", description: "Tinkerer, learner" },
+        { label: "Other", value: "other", description: "Something else entirely" }
+      ],
+      options: ["engineer", "designer", "founder", "hobbyist", "other"],
+      processor: (answer, user) => {
+        const role = answer.trim().toLowerCase() || "engineer";
+        return {
+          ...user,
+          identity: { ...user.identity, role },
+          completedSteps: [...user.completedSteps, "role"]
+        };
+      }
+    },
+    {
+      step: "projects",
+      question: "What are you working on? (one short line, optional - press Enter to skip)",
+      processor: (answer, user) => {
+        const desc = answer.trim();
+        if (!desc) {
+          return {
+            ...user,
+            completedSteps: [...user.completedSteps, "projects"]
+          };
+        }
+        return {
+          ...user,
+          projects: {
+            ...user.projects,
+            primary: desc,
+            all: user.projects.all.includes(desc) ? user.projects.all : [...user.projects.all, desc],
+            descriptions: { ...user.projects.descriptions, [desc]: desc }
+          },
+          completedSteps: [...user.completedSteps, "projects"]
         };
       }
     },
     {
       step: "communication",
-      question: `How should I communicate with you?
-
-` + `1. Concise & direct (just the facts)
-` + `2. Detailed & explanatory (teach me as we go)
-` + `3. Casual & friendly (we're collaborators)
-` + "4. Formal & precise (professional tone)",
-      options: ["1", "2", "3", "4", "concise", "detailed", "casual", "formal"],
+      question: "How should I communicate with you?",
+      kind: "select",
+      choices: [
+        {
+          label: "Dry-witted, sarcastic, seriously motivational",
+          value: "1",
+          description: "Roast me into greatness"
+        },
+        { label: "Concise & direct", value: "2", description: "Just the facts" },
+        { label: "Detailed & explanatory", value: "3", description: "Teach me as we go" },
+        { label: "Casual & friendly", value: "4", description: "We're collaborators" },
+        { label: "Formal & precise", value: "5", description: "Professional tone" }
+      ],
+      options: ["1", "2", "3", "4", "5", "sarcastic", "concise", "detailed", "casual", "formal"],
       processor: (answer, user) => {
         const styleMap = {
-          "1": "concise",
-          "2": "detailed",
-          "3": "casual",
-          "4": "formal",
+          "1": "sarcastic",
+          "2": "concise",
+          "3": "detailed",
+          "4": "casual",
+          "5": "formal",
+          sarcastic: "sarcastic",
           concise: "concise",
           detailed: "detailed",
           casual: "casual",
           formal: "formal"
         };
-        const style = styleMap[answer.toLowerCase()] || "concise";
+        const style = styleMap[answer.toLowerCase()] || "sarcastic";
         return {
           ...user,
           identity: { ...user.identity, communicationStyle: style },
@@ -504984,6 +505251,110 @@ var init_onboarding = __esm(() => {
         };
       }
     },
+    {
+      step: "provider-check-ollama",
+      question: "Provider check: Ollama (local LLM runtime)",
+      kind: "providerCheck",
+      provider: "ollama",
+      installHint: PROVIDER_INSTALL_HINTS.ollama,
+      processor: (answer, user) => {
+        const live = answer === "live";
+        return {
+          ...user,
+          integrations: {
+            ...user.integrations,
+            ollama: {
+              ...user.integrations.ollama,
+              available: live || user.integrations.ollama.available
+            }
+          },
+          completedSteps: [...user.completedSteps, "provider-check-ollama"]
+        };
+      }
+    },
+    {
+      step: "provider-check-lmstudio",
+      question: "Provider check: LM Studio (local LLM runtime)",
+      kind: "providerCheck",
+      provider: "lmstudio",
+      installHint: PROVIDER_INSTALL_HINTS.lmstudio,
+      processor: (answer, user) => {
+        const live = answer === "live";
+        return {
+          ...user,
+          integrations: {
+            ...user.integrations,
+            lmstudio: {
+              ...user.integrations.lmstudio,
+              available: live || user.integrations.lmstudio.available
+            }
+          },
+          completedSteps: [...user.completedSteps, "provider-check-lmstudio"]
+        };
+      }
+    },
+    {
+      step: "provider-check-apfel",
+      question: "Provider check: apfel (Apple Foundation Model)",
+      kind: "providerCheck",
+      provider: "apfel",
+      installHint: PROVIDER_INSTALL_HINTS.apfel,
+      processor: (_answer, user) => ({
+        ...user,
+        completedSteps: [...user.completedSteps, "provider-check-apfel"]
+      })
+    },
+    {
+      step: "agent-name-orchestrator",
+      question: `Name your Orchestrator agent. (default: Orchestrator)
+
+` + "Press Enter to keep, or type a custom name (e.g. Architect, Plato):",
+      kind: "agentName",
+      roleKey: "orchestrator",
+      default: "Orchestrator",
+      processor: (answer, user) => {
+        const chosen = answer.trim() || DEFAULT_SETTINGS.agents.names.orchestrator;
+        persistAgentName("orchestrator", chosen);
+        return {
+          ...user,
+          completedSteps: [...user.completedSteps, "agent-name-orchestrator"]
+        };
+      }
+    },
+    {
+      step: "agent-name-engineer",
+      question: `Name your Engineer agent. (default: Engineer)
+
+` + "Press Enter to keep, or type a custom name (e.g. Coder, Hephaestus):",
+      kind: "agentName",
+      roleKey: "engineer",
+      default: "Engineer",
+      processor: (answer, user) => {
+        const chosen = answer.trim() || DEFAULT_SETTINGS.agents.names.engineer;
+        persistAgentName("engineer", chosen);
+        return {
+          ...user,
+          completedSteps: [...user.completedSteps, "agent-name-engineer"]
+        };
+      }
+    },
+    {
+      step: "agent-name-qa",
+      question: `Name your QA agent. (default: QA)
+
+` + "Press Enter to keep, or type a custom name (e.g. Reviewer, Cassandra):",
+      kind: "agentName",
+      roleKey: "qa",
+      default: "QA",
+      processor: (answer, user) => {
+        const chosen = answer.trim() || DEFAULT_SETTINGS.agents.names.qa;
+        persistAgentName("qa", chosen);
+        return {
+          ...user,
+          completedSteps: [...user.completedSteps, "agent-name-qa"]
+        };
+      }
+    },
     {
       step: "voice",
       question: `What should your 8gent be called? (default: Eight)
@@ -505012,12 +505383,20 @@ var init_onboarding = __esm(() => {
 
 ` + `This downloads KittenTTS - a free, local neural text-to-speech engine.
 ` + `No API keys needed. Runs entirely on your machine.
-` + `Download size: ~200MB (model + dependencies)
-
-` + `1. Yes, install AI voices (recommended)
-` + `2. No, use system voices only
-
-` + "Choose 1-2:",
+` + "Download size: ~200MB (model + dependencies)",
+      kind: "select",
+      choices: [
+        {
+          label: "Yes, install AI voices",
+          value: "1",
+          description: "Recommended. Free local neural TTS via KittenTTS."
+        },
+        {
+          label: "No, use system voices only",
+          value: "2",
+          description: "Skip the download. Use macOS built-in voices."
+        }
+      ],
       options: ["1", "2", "yes", "no", "y", "n"],
       processor: (answer, user) => {
         const wantsAI = ["1", "yes", "y"].includes(answer.toLowerCase());
@@ -505052,26 +505431,23 @@ var init_onboarding = __esm(() => {
     },
     {
       step: "voice-picker",
-      question: `Pick a voice for your agent:
-
-` + `  AI Voices (KittenTTS - neural, natural-sounding):
-` + `  1. Bruno   (male, warm & authoritative - recommended)
-` + `  2. Bella   (female, warm & clear)
-` + `  3. Jasper  (male, crisp & technical)
-` + `  4. Luna    (female, soft & creative)
-` + `  5. Rosie   (female, bright & energetic)
-` + `  6. Hugo    (male, neutral & steady)
-` + `  7. Kiki    (female, light & friendly)
-` + `  8. Leo     (male, rich & expressive)
-
-` + `  System Voices (macOS built-in):
-` + `  9.  Moira    (Irish)
-` + `  10. Daniel   (British)
-` + `  11. Samantha (American)
-` + `  12. Karen    (Australian)
-` + `  13. Rishi    (Indian)
-
-` + "Choose 1-13 (default: 1 - Bruno):",
+      question: "Pick a voice for your agent.",
+      kind: "select",
+      choices: [
+        { label: "Bruno", value: "1", description: "AI - male, warm & authoritative (recommended)" },
+        { label: "Bella", value: "2", description: "AI - female, warm & clear" },
+        { label: "Jasper", value: "3", description: "AI - male, crisp & technical" },
+        { label: "Luna", value: "4", description: "AI - female, soft & creative" },
+        { label: "Rosie", value: "5", description: "AI - female, bright & energetic" },
+        { label: "Hugo", value: "6", description: "AI - male, neutral & steady" },
+        { label: "Kiki", value: "7", description: "AI - female, light & friendly" },
+        { label: "Leo", value: "8", description: "AI - male, rich & expressive" },
+        { label: "Moira", value: "9", description: "System - Irish (macOS)" },
+        { label: "Daniel", value: "10", description: "System - British (macOS)" },
+        { label: "Samantha", value: "11", description: "System - American (macOS)" },
+        { label: "Karen", value: "12", description: "System - Australian (macOS)" },
+        { label: "Rishi", value: "13", description: "System - Indian (macOS)" }
+      ],
       options: ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13"],
       processor: (answer, user) => {
         const kittenVoices = {
@@ -505115,13 +505491,22 @@ var init_onboarding = __esm(() => {
       question: `Excellent. All set:
 
 ` + `- Name: {name}
+` + `- Role: {role}
+` + `- Project: {project}
 ` + `- Style: {style}
 ` + `- Provider: {provider}
-` + `- Agent: {agent_name}
+` + `- 8gent: {agent_name}
 ` + `- Voice: {voice}
+` + `- Orchestrator: {agent_orchestrator}
+` + `- Engineer: {agent_engineer}
+` + `- QA: {agent_qa}
 
-` + `Ready to begin? (yes/no)
-`,
+` + "Ready to begin?",
+      kind: "select",
+      choices: [
+        { label: "Yes, let's go", value: "yes" },
+        { label: "No, restart later", value: "no" }
+      ],
       options: ["yes", "no", "y", "n"],
       processor: (answer, user) => {
         return {
@@ -505146,11 +505531,11 @@ var init_onboarding = __esm(() => {
 });
 
 // packages/skills/compound.ts
-import { homedir as homedir23 } from "os";
-import { join as join42 } from "path";
+import { homedir as homedir24 } from "os";
+import { join as join43 } from "path";
 var LEARNED_SKILLS_DIR;
 var init_compound = __esm(() => {
-  LEARNED_SKILLS_DIR = join42(homedir23(), ".8gent", "learned-skills");
+  LEARNED_SKILLS_DIR = join43(homedir24(), ".8gent", "learned-skills");
 });
 
 // packages/skills/matcher.ts
@@ -505159,11 +505544,11 @@ var init_matcher = __esm(() => {
 });
 
 // packages/skills/experiment.ts
-import { join as join43 } from "path";
+import { join as join44 } from "path";
 var EXPERIMENTS_DIR;
 var init_experiment = __esm(() => {
   init_compound();
-  EXPERIMENTS_DIR = join43(LEARNED_SKILLS_DIR, ".experiments");
+  EXPERIMENTS_DIR = join44(LEARNED_SKILLS_DIR, ".experiments");
 });
 
 // packages/skills/creator.ts
@@ -505217,9 +505602,9 @@ var init_creator = __esm(() => {
 });
 
 // packages/skills/index.ts
-import * as fs33 from "fs";
-import * as os23 from "os";
-import * as path34 from "path";
+import * as fs34 from "fs";
+import * as os24 from "os";
+import * as path35 from "path";
 import { fileURLToPath } from "url";
 function parseFrontmatter(content) {
   const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
@@ -505260,21 +505645,21 @@ function parseFrontmatter(content) {
   };
 }
 function collectNestedSkillMdPaths(skillsRoot) {
-  if (!fs33.existsSync(skillsRoot))
+  if (!fs34.existsSync(skillsRoot))
     return [];
   const out = [];
-  for (const name21 of fs33.readdirSync(skillsRoot)) {
-    const skillMd = path34.join(skillsRoot, name21, "SKILL.md");
-    if (fs33.existsSync(skillMd)) {
+  for (const name21 of fs34.readdirSync(skillsRoot)) {
+    const skillMd = path35.join(skillsRoot, name21, "SKILL.md");
+    if (fs34.existsSync(skillMd)) {
       out.push(skillMd);
     }
   }
   return out;
 }
 function discoverBundledSkillMdFiles() {
-  const entryDir = path34.dirname(fileURLToPath(import.meta.url));
+  const entryDir = path35.dirname(fileURLToPath(import.meta.url));
   const nested = [...collectNestedSkillMdPaths(entryDir)];
-  nested.push(...collectNestedSkillMdPaths(path34.join(entryDir, "skills")));
+  nested.push(...collectNestedSkillMdPaths(path35.join(entryDir, "skills")));
   return nested;
 }
 
@@ -505284,31 +505669,31 @@ class SkillManager {
   skillsDirectory;
   invocations = new Map;
   constructor(skillsDirectory) {
-    this.skillsDirectory = skillsDirectory || path34.join(os23.homedir(), ".8gent", "skills");
+    this.skillsDirectory = skillsDirectory || path35.join(os24.homedir(), ".8gent", "skills");
   }
   async loadSkills() {
     this.skills.clear();
     this.aliasToCanonical.clear();
-    if (!fs33.existsSync(this.skillsDirectory)) {
-      fs33.mkdirSync(this.skillsDirectory, { recursive: true });
+    if (!fs34.existsSync(this.skillsDirectory)) {
+      fs34.mkdirSync(this.skillsDirectory, { recursive: true });
       this.createExampleSkill();
     }
-    const files = fs33.readdirSync(this.skillsDirectory);
+    const files = fs34.readdirSync(this.skillsDirectory);
     const skillFiles = files.filter((f3) => f3.endsWith(".md"));
     for (const file2 of skillFiles) {
-      this.tryIngestSkillFile(path34.join(this.skillsDirectory, file2), false);
+      this.tryIngestSkillFile(path35.join(this.skillsDirectory, file2), false);
     }
-    const claudeSkillsRoot = path34.join(process.cwd(), ".claude", "skills");
+    const claudeSkillsRoot = path35.join(process.cwd(), ".claude", "skills");
     for (const filePath of collectNestedSkillMdPaths(claudeSkillsRoot)) {
       this.tryIngestSkillFile(filePath, true);
     }
     for (const filePath of discoverBundledSkillMdFiles()) {
       this.tryIngestSkillFile(filePath, true);
     }
-    if (fs33.existsSync(LEARNED_DIR)) {
-      const learnedFiles = fs33.readdirSync(LEARNED_DIR).filter((f3) => f3.endsWith(".md"));
+    if (fs34.existsSync(LEARNED_DIR)) {
+      const learnedFiles = fs34.readdirSync(LEARNED_DIR).filter((f3) => f3.endsWith(".md"));
       for (const file2 of learnedFiles) {
-        this.tryIngestSkillFile(path34.join(LEARNED_DIR, file2), true);
+        this.tryIngestSkillFile(path35.join(LEARNED_DIR, file2), true);
       }
     }
     return this.getAllSkills();
@@ -505346,7 +505731,7 @@ class SkillManager {
   }
   tryIngestSkillFile(filePath, skipIfExists) {
     try {
-      const content = fs33.readFileSync(filePath, "utf-8");
+      const content = fs34.readFileSync(filePath, "utf-8");
       const { frontmatter, body } = parseFrontmatter(content);
       if (skipIfExists && this.skills.has(frontmatter.name))
         return;
@@ -505391,8 +505776,8 @@ examples:
 - Don't commit node_modules, .env, or other sensitive files
 - Group related changes into single commits
 `;
-    const filePath = path34.join(this.skillsDirectory, "commit.md");
-    fs33.writeFileSync(filePath, exampleSkill);
+    const filePath = path35.join(this.skillsDirectory, "commit.md");
+    fs34.writeFileSync(filePath, exampleSkill);
     console.log(`[skills] Created example skill: ${filePath}`);
   }
   getSkill(name21) {
@@ -505480,8 +505865,8 @@ ${skill.examples.map((e3) => `  - ${e3}`).join(`
 ${skill.prompt}
 `;
     const fileName = `${skill.name.toLowerCase().replace(/\s+/g, "-")}.md`;
-    const filePath = path34.join(this.skillsDirectory, fileName);
-    fs33.writeFileSync(filePath, content);
+    const filePath = path35.join(this.skillsDirectory, fileName);
+    fs34.writeFileSync(filePath, content);
     skill.filePath = filePath;
     this.skills.set(skill.name, skill);
   }
@@ -505547,14 +505932,14 @@ var init_skills = __esm(() => {
   init_matcher();
   init_experiment();
   init_creator();
-  LEARNED_DIR = path34.join(os23.homedir(), ".8gent", "learned-skills");
+  LEARNED_DIR = path35.join(os24.homedir(), ".8gent", "learned-skills");
 });
 
 // packages/tasks/index.ts
 import { EventEmitter as EventEmitter8 } from "events";
-import * as fs34 from "fs";
-import * as os24 from "os";
-import * as path35 from "path";
+import * as fs35 from "fs";
+import * as os25 from "os";
+import * as path36 from "path";
 function getTaskManager(storePath) {
   if (!taskManagerInstance2) {
     taskManagerInstance2 = new TaskManager(storePath);
@@ -505689,17 +506074,17 @@ var init_tasks = __esm(() => {
     autoSave = true;
     constructor(storePath) {
       super();
-      this.storePath = storePath || path35.join(os24.homedir(), ".8gent", "tasks.json");
+      this.storePath = storePath || path36.join(os25.homedir(), ".8gent", "tasks.json");
       this.store = this.loadStore();
     }
     loadStore() {
-      const dir = path35.dirname(this.storePath);
-      if (!fs34.existsSync(dir)) {
-        fs34.mkdirSync(dir, { recursive: true });
+      const dir = path36.dirname(this.storePath);
+      if (!fs35.existsSync(dir)) {
+        fs35.mkdirSync(dir, { recursive: true });
       }
-      if (fs34.existsSync(this.storePath)) {
+      if (fs35.existsSync(this.storePath)) {
         try {
-          const data2 = fs34.readFileSync(this.storePath, "utf-8");
+          const data2 = fs35.readFileSync(this.storePath, "utf-8");
           const store = JSON.parse(data2);
           for (const task of [...store.tasks, ...store.archivedTasks]) {
             const match = task.id.match(/^task-(\d+)/);
@@ -505724,7 +506109,7 @@ var init_tasks = __esm(() => {
     }
     saveStore() {
       this.store.lastUpdated = new Date().toISOString();
-      fs34.writeFileSync(this.storePath, JSON.stringify(this.store, null, 2));
+      fs35.writeFileSync(this.storePath, JSON.stringify(this.store, null, 2));
     }
     generateId() {
       this.idCounter++;
@@ -506435,8 +506820,8 @@ class ProactivePlanner {
     for (const cmd of commands.slice(0, 5)) {
       const fileMatch = cmd.match(/(?:src|lib|packages)\/[\w/.-]+\.(ts|tsx|js|jsx)/);
       if (fileMatch) {
-        const path36 = fileMatch[0];
-        const dir = path36.split("/").slice(0, -1).join("/");
+        const path37 = fileMatch[0];
+        const dir = path37.split("/").slice(0, -1).join("/");
         patterns.push({
           target: `files in ${dir}`,
           path: dir,
@@ -506467,15 +506852,15 @@ __export(exports_modes, {
   ModeManager: () => ModeManager,
   FAST_MODE_MODELS: () => FAST_MODE_MODELS
 });
-import * as fs35 from "fs";
-import * as os25 from "os";
-import * as path36 from "path";
+import * as fs36 from "fs";
+import * as os26 from "os";
+import * as path37 from "path";
 function loadCustomModes(filePath) {
   const result = {};
-  if (!fs35.existsSync(filePath))
+  if (!fs36.existsSync(filePath))
     return result;
   try {
-    const raw = fs35.readFileSync(filePath, "utf-8");
+    const raw = fs36.readFileSync(filePath, "utf-8");
     const parsed = $parse(raw);
     if (!parsed?.modes || typeof parsed.modes !== "object")
       return result;
@@ -506504,7 +506889,7 @@ class ModeManager {
   _fastMode = false;
   _previousModel = null;
   constructor(customModesPath) {
-    const modesPath = customModesPath || path36.join(process.env.EIGHT_DATA_DIR || path36.join(os25.homedir(), ".8gent"), "modes.yaml");
+    const modesPath = customModesPath || path37.join(process.env.EIGHT_DATA_DIR || path37.join(os26.homedir(), ".8gent"), "modes.yaml");
     this.modes = { ...BUILT_IN_MODES, ...loadCustomModes(modesPath) };
   }
   getMode(name21) {
@@ -506648,21 +507033,21 @@ __export(exports_i18n, {
   LanguageManager: () => LanguageManager,
   LANGUAGES: () => LANGUAGES
 });
-import * as fs36 from "fs";
-import * as os26 from "os";
-import * as path37 from "path";
+import * as fs37 from "fs";
+import * as os27 from "os";
+import * as path38 from "path";
 
 class LanguageManager {
   settings;
   settingsPath;
   constructor(settingsPath) {
-    this.settingsPath = settingsPath || path37.join(os26.homedir(), ".8gent", "language.json");
+    this.settingsPath = settingsPath || path38.join(os27.homedir(), ".8gent", "language.json");
     this.settings = this.loadSettings();
   }
   loadSettings() {
     try {
-      if (fs36.existsSync(this.settingsPath)) {
-        const data2 = fs36.readFileSync(this.settingsPath, "utf-8");
+      if (fs37.existsSync(this.settingsPath)) {
+        const data2 = fs37.readFileSync(this.settingsPath, "utf-8");
         return JSON.parse(data2);
       }
     } catch (err) {}
@@ -506672,11 +507057,11 @@ class LanguageManager {
     };
   }
   saveSettings() {
-    const dir = path37.dirname(this.settingsPath);
-    if (!fs36.existsSync(dir)) {
-      fs36.mkdirSync(dir, { recursive: true });
+    const dir = path38.dirname(this.settingsPath);
+    if (!fs37.existsSync(dir)) {
+      fs37.mkdirSync(dir, { recursive: true });
     }
-    fs36.writeFileSync(this.settingsPath, JSON.stringify(this.settings, null, 2));
+    fs37.writeFileSync(this.settingsPath, JSON.stringify(this.settings, null, 2));
   }
   getActiveLanguage() {
     return LANGUAGES[this.settings.activeLanguage] || LANGUAGES.en;
@@ -506921,15 +507306,15 @@ var init_i18n = __esm(() => {
 });
 
 // packages/eight/repl.ts
-import * as fs37 from "fs";
-import * as os27 from "os";
-import * as path38 from "path";
+import * as fs38 from "fs";
+import * as os28 from "os";
+import * as path39 from "path";
 import * as readline2 from "readline";
 async function startREPL(config2) {
-  const configPath = path38.join(os27.homedir(), ".8gent", "config.json");
+  const configPath = path39.join(os28.homedir(), ".8gent", "config.json");
   let savedConfig = {};
-  if (fs37.existsSync(configPath)) {
-    savedConfig = JSON.parse(fs37.readFileSync(configPath, "utf-8"));
+  if (fs38.existsSync(configPath)) {
+    savedConfig = JSON.parse(fs38.readFileSync(configPath, "utf-8"));
   }
   const finalConfig = {
     model: config2?.model || savedConfig.model || "glm-4.7-flash:latest",
@@ -507461,13 +507846,13 @@ Output format: PLAN: 1) ... 2) ... 3) ...`;
     return true;
   }
   if (trimmed === "/nightly") {
-    const nightlyLog = path38.join(os27.homedir(), ".8gent", "nightly.log");
-    const dreamsLog = path38.join(os27.homedir(), ".8gent", "dreams.log");
+    const nightlyLog = path39.join(os28.homedir(), ".8gent", "nightly.log");
+    const dreamsLog = path39.join(os28.homedir(), ".8gent", "dreams.log");
     console.log(`
 \x1B[36m8gent Nightly Training Status:\x1B[0m
 `);
-    if (fs37.existsSync(nightlyLog)) {
-      const content = fs37.readFileSync(nightlyLog, "utf-8");
+    if (fs38.existsSync(nightlyLog)) {
+      const content = fs38.readFileSync(nightlyLog, "utf-8");
       const lines = content.trim().split(`
 `);
       const tail = lines.slice(-25);
@@ -507487,8 +507872,8 @@ Output format: PLAN: 1) ... 2) ... 3) ...`;
       console.log("  \x1B[33mNo nightly training log found.\x1B[0m");
       console.log("  Nightly training runs at 2:00 AM PST via cron.");
     }
-    if (fs37.existsSync(dreamsLog)) {
-      const content = fs37.readFileSync(dreamsLog, "utf-8");
+    if (fs38.existsSync(dreamsLog)) {
+      const content = fs38.readFileSync(dreamsLog, "utf-8");
       const lines = content.trim().split(`
 `);
       const tail = lines.slice(-10);
@@ -507697,9 +508082,9 @@ async function handleVoiceCommands(trimmed) {
 }
 function handlePersonalCommands(trimmed) {
   if (trimmed === "/personal" || trimmed === "/personal status") {
-    const loraDir = path38.join(os27.homedir(), ".8gent", "personal-lora");
-    const metaPath = path38.join(loraDir, "meta.json");
-    if (!fs37.existsSync(loraDir) || !fs37.existsSync(metaPath)) {
+    const loraDir = path39.join(os28.homedir(), ".8gent", "personal-lora");
+    const metaPath = path39.join(loraDir, "meta.json");
+    if (!fs38.existsSync(loraDir) || !fs38.existsSync(metaPath)) {
       console.log(`
 \x1B[33mPersonal LoRA:\x1B[0m Not configured`);
       console.log(`  No personal LoRA found at ${loraDir}`);
@@ -507708,7 +508093,7 @@ function handlePersonalCommands(trimmed) {
       return true;
     }
     try {
-      const meta3 = JSON.parse(fs37.readFileSync(metaPath, "utf-8"));
+      const meta3 = JSON.parse(fs38.readFileSync(metaPath, "utf-8"));
       console.log(`
 \x1B[36mPersonal LoRA Status:\x1B[0m`);
       console.log(`  Path:            ${loraDir}`);
@@ -507731,9 +508116,9 @@ function handlePersonalCommands(trimmed) {
     return true;
   }
   if (trimmed === "/personal reset") {
-    const loraDir = path38.join(os27.homedir(), ".8gent", "personal-lora");
-    if (fs37.existsSync(loraDir)) {
-      fs37.rmSync(loraDir, { recursive: true, force: true });
+    const loraDir = path39.join(os28.homedir(), ".8gent", "personal-lora");
+    if (fs38.existsSync(loraDir)) {
+      fs38.rmSync(loraDir, { recursive: true, force: true });
       console.log("\x1B[32mPersonal LoRA reset. Reverted to base Eight.\x1B[0m");
     } else {
       console.log("No personal LoRA to reset.");
@@ -508412,8 +508797,8 @@ var init_repl = __esm(() => {
 
 // packages/eight/harness/session.ts
 import * as crypto6 from "crypto";
-import * as fs38 from "fs";
-import * as path39 from "path";
+import * as fs39 from "fs";
+import * as path40 from "path";
 function computeHash(id, timestamp, type, payload, prevHash) {
   const data2 = JSON.stringify({ id, timestamp, type, payload, prevHash });
   return crypto6.createHash("sha256").update(data2).digest("hex");
@@ -508427,8 +508812,8 @@ function parseLine(line) {
 }
 function createSession(sessionId) {
   const id = sessionId || crypto6.randomUUID().slice(0, 12);
-  const filePath = path39.join(SESSIONS_DIR, `${id}.jsonl`);
-  fs38.mkdirSync(SESSIONS_DIR, { recursive: true, mode: 448 });
+  const filePath = path40.join(SESSIONS_DIR, `${id}.jsonl`);
+  fs39.mkdirSync(SESSIONS_DIR, { recursive: true, mode: 448 });
   let cachedLastHash = null;
   async function getLastHash() {
     if (cachedLastHash !== null)
@@ -508438,9 +508823,9 @@ function createSession(sessionId) {
     return cachedLastHash;
   }
   async function readAllEntries() {
-    if (!fs38.existsSync(filePath))
+    if (!fs39.existsSync(filePath))
       return [];
-    const content = fs38.readFileSync(filePath, "utf-8").trim();
+    const content = fs39.readFileSync(filePath, "utf-8").trim();
     if (!content)
       return [];
     return content.split(`
@@ -508464,7 +508849,7 @@ function createSession(sessionId) {
       };
       const line = `${JSON.stringify(entry)}
 `;
-      fs38.appendFileSync(filePath, line, { encoding: "utf-8", mode: 384 });
+      fs39.appendFileSync(filePath, line, { encoding: "utf-8", mode: 384 });
       cachedLastHash = hash2;
       return hash2;
     },
@@ -508492,23 +508877,23 @@ function createSession(sessionId) {
   return session;
 }
 function openSession(sessionId) {
-  const filePath = path39.join(SESSIONS_DIR, `${sessionId}.jsonl`);
-  if (!fs38.existsSync(filePath)) {
+  const filePath = path40.join(SESSIONS_DIR, `${sessionId}.jsonl`);
+  if (!fs39.existsSync(filePath)) {
     throw new Error(`Session not found: ${sessionId}`);
   }
   return createSession(sessionId);
 }
 function listSessions() {
-  if (!fs38.existsSync(SESSIONS_DIR))
+  if (!fs39.existsSync(SESSIONS_DIR))
     return [];
-  return fs38.readdirSync(SESSIONS_DIR).filter((f3) => f3.endsWith(".jsonl")).map((f3) => f3.replace(".jsonl", "")).sort();
+  return fs39.readdirSync(SESSIONS_DIR).filter((f3) => f3.endsWith(".jsonl")).map((f3) => f3.replace(".jsonl", "")).sort();
 }
 function getSessionsDir() {
   return SESSIONS_DIR;
 }
 var SESSIONS_DIR;
 var init_session = __esm(() => {
-  SESSIONS_DIR = path39.join(process.env.HOME || "~", ".8gent", "audit");
+  SESSIONS_DIR = path40.join(process.env.HOME || "~", ".8gent", "audit");
 });
 
 // packages/eight/harness/harness.ts
@@ -508643,12 +509028,12 @@ function createSandbox(vault) {
 }
 
 // packages/eight/harness/vault.ts
-import * as fs39 from "fs";
+import * as fs40 from "fs";
 function parseDotenv(filePath) {
-  if (!fs39.existsSync(filePath))
+  if (!fs40.existsSync(filePath))
     return {};
   const result = {};
-  const lines = fs39.readFileSync(filePath, "utf-8").split(`
+  const lines = fs40.readFileSync(filePath, "utf-8").split(`
 `);
   for (const line of lines) {
     const trimmed = line.trim();
@@ -509446,19 +509831,19 @@ What alternative approach will you try now?`;
 });
 
 // benchmarks/autoresearch/model-router.ts
-import { existsSync as existsSync44, readFileSync as readFileSync37, writeFileSync as writeFileSync22 } from "fs";
-import { join as join50 } from "path";
+import { existsSync as existsSync45, readFileSync as readFileSync38, writeFileSync as writeFileSync23 } from "fs";
+import { join as join51 } from "path";
 function loadExperience() {
   try {
-    if (existsSync44(EXPERIENCE_FILE)) {
-      return JSON.parse(readFileSync37(EXPERIENCE_FILE, "utf-8"));
+    if (existsSync45(EXPERIENCE_FILE)) {
+      return JSON.parse(readFileSync38(EXPERIENCE_FILE, "utf-8"));
     }
   } catch {}
   return { byDomain: {}, byBenchmark: {}, runCounts: {}, updatedAt: "" };
 }
 function saveExperience(db2) {
   db2.updatedAt = new Date().toISOString();
-  writeFileSync22(EXPERIENCE_FILE, JSON.stringify(db2, null, 2));
+  writeFileSync23(EXPERIENCE_FILE, JSON.stringify(db2, null, 2));
 }
 function recordResult(model, domain2, benchmarkId, score) {
   const db2 = loadExperience();
@@ -509485,12 +509870,12 @@ function recordResult(model, domain2, benchmarkId, score) {
 }
 var ROOT, EXPERIENCE_FILE;
 var init_model_router = __esm(() => {
-  ROOT = join50(import.meta.dir, "..");
-  EXPERIENCE_FILE = join50(ROOT, "autoresearch", "model-experience.json");
+  ROOT = join51(import.meta.dir, "..");
+  EXPERIENCE_FILE = join51(ROOT, "autoresearch", "model-experience.json");
 });
 
 // packages/kernel/judge.ts
-import { existsSync as existsSync45, mkdirSync as mkdirSync30, readFileSync as readFileSync38, writeFileSync as writeFileSync23 } from "fs";
+import { existsSync as existsSync46, mkdirSync as mkdirSync31, readFileSync as readFileSync39, writeFileSync as writeFileSync24 } from "fs";
 import { dirname as dirname18 } from "path";
 
 class JudgeScorer {
@@ -509601,8 +509986,8 @@ Score this response:`;
   }
   loadHistory() {
     try {
-      if (existsSync45(this.config.historyPath)) {
-        return JSON.parse(readFileSync38(this.config.historyPath, "utf-8"));
+      if (existsSync46(this.config.historyPath)) {
+        return JSON.parse(readFileSync39(this.config.historyPath, "utf-8"));
       }
     } catch {}
     return {
@@ -509635,9 +510020,9 @@ Score this response:`;
     }
     history.updatedAt = new Date().toISOString();
     const dir = dirname18(this.config.historyPath);
-    if (!existsSync45(dir))
-      mkdirSync30(dir, { recursive: true });
-    writeFileSync23(this.config.historyPath, JSON.stringify(history, null, 2));
+    if (!existsSync46(dir))
+      mkdirSync31(dir, { recursive: true });
+    writeFileSync24(this.config.historyPath, JSON.stringify(history, null, 2));
   }
 }
 function clamp2(v4) {
@@ -509669,7 +510054,7 @@ var init_judge = __esm(() => {
 });
 
 // packages/kernel/proxy.ts
-import { existsSync as existsSync46 } from "fs";
+import { existsSync as existsSync47 } from "fs";
 import { resolve as resolve10 } from "path";
 var {spawn: spawn10 } = globalThis.Bun;
 
@@ -509693,7 +510078,7 @@ class TrainingProxy {
       throw new Error(`Ollama not reachable at ${this.config.ollamaUrl}`);
     }
     const configPath = resolve10(this.config.configPath);
-    if (!existsSync46(configPath)) {
+    if (!existsSync47(configPath)) {
       throw new Error(`Training proxy config not found at ${configPath}`);
     }
     this.process = spawn10({
@@ -509825,8 +510210,8 @@ var init_proxy = __esm(() => {
 });
 
 // packages/kernel/training.ts
-import { existsSync as existsSync47, mkdirSync as mkdirSync31, readFileSync as readFileSync40, writeFileSync as writeFileSync24 } from "fs";
-import { dirname as dirname19, join as join52 } from "path";
+import { existsSync as existsSync48, mkdirSync as mkdirSync32, readFileSync as readFileSync41, writeFileSync as writeFileSync25 } from "fs";
+import { dirname as dirname19, join as join53 } from "path";
 var {spawn: spawn11 } = globalThis.Bun;
 
 class TrainingOrchestrator {
@@ -509885,8 +510270,8 @@ class TrainingOrchestrator {
       batchId,
       createdAt: new Date().toISOString()
     };
-    const batchPath = join52(this.config.dataDir, "batches", `${batchId}.json`);
-    writeFileSync24(batchPath, JSON.stringify(batch, null, 2));
+    const batchPath = join53(this.config.dataDir, "batches", `${batchId}.json`);
+    writeFileSync25(batchPath, JSON.stringify(batch, null, 2));
     this.state.currentBatch = [];
     this.state.totalTrainingRuns += 1;
     this.saveState();
@@ -509970,9 +510355,9 @@ class TrainingOrchestrator {
     const exitCode = await proc.exited;
     const stdout = await new Response(proc.stdout).text();
     try {
-      const resultsPath = join52(dirname19(this.config.validateCommand.split(" ").pop()), "checkpoint-results.json");
-      if (existsSync47(resultsPath)) {
-        const results = JSON.parse(readFileSync40(resultsPath, "utf-8"));
+      const resultsPath = join53(dirname19(this.config.validateCommand.split(" ").pop()), "checkpoint-results.json");
+      if (existsSync48(resultsPath)) {
+        const results = JSON.parse(readFileSync41(resultsPath, "utf-8"));
         return results.avgScore ?? 0;
       }
     } catch {}
@@ -509990,10 +510375,10 @@ class TrainingOrchestrator {
     } catch {}
   }
   loadState() {
-    const statePath = join52(this.config.dataDir, "state.json");
+    const statePath = join53(this.config.dataDir, "state.json");
     try {
-      if (existsSync47(statePath)) {
-        return JSON.parse(readFileSync40(statePath, "utf-8"));
+      if (existsSync48(statePath)) {
+        return JSON.parse(readFileSync41(statePath, "utf-8"));
       }
     } catch {}
     return {
@@ -510007,15 +510392,15 @@ class TrainingOrchestrator {
     };
   }
   saveState() {
-    const statePath = join52(this.config.dataDir, "state.json");
+    const statePath = join53(this.config.dataDir, "state.json");
     this.state.updatedAt = new Date().toISOString();
-    writeFileSync24(statePath, JSON.stringify(this.state, null, 2));
+    writeFileSync25(statePath, JSON.stringify(this.state, null, 2));
   }
   ensureDirs() {
     for (const sub of ["batches", "checkpoints"]) {
-      const dir = join52(this.config.dataDir, sub);
-      if (!existsSync47(dir))
-        mkdirSync31(dir, { recursive: true });
+      const dir = join53(this.config.dataDir, sub);
+      if (!existsSync48(dir))
+        mkdirSync32(dir, { recursive: true });
     }
   }
 }
@@ -510222,8 +510607,8 @@ var init_loop = __esm(() => {
 });
 
 // packages/kernel/personal-collector.ts
-import { appendFileSync as appendFileSync9, existsSync as existsSync48, mkdirSync as mkdirSync32, readFileSync as readFileSync41, writeFileSync as writeFileSync25 } from "fs";
-import { join as join53, resolve as resolve11 } from "path";
+import { appendFileSync as appendFileSync9, existsSync as existsSync49, mkdirSync as mkdirSync33, readFileSync as readFileSync42, writeFileSync as writeFileSync26 } from "fs";
+import { join as join54, resolve as resolve11 } from "path";
 
 class PersonalCollector {
   trainingDir;
@@ -510233,8 +510618,8 @@ class PersonalCollector {
   stats;
   constructor(projectRoot = process.cwd(), minScore = 0.7) {
     this.trainingDir = resolve11(projectRoot, ".8gent", "kernel", "training");
-    this.pairsPath = join53(this.trainingDir, "pairs.jsonl");
-    this.statsPath = join53(this.trainingDir, "stats.json");
+    this.pairsPath = join54(this.trainingDir, "pairs.jsonl");
+    this.statsPath = join54(this.trainingDir, "stats.json");
     this.minScore = minScore;
     this.stats = this.loadStats();
   }
@@ -510273,9 +510658,9 @@ class PersonalCollector {
     return true;
   }
   getPairs(userId) {
-    if (!existsSync48(this.pairsPath))
+    if (!existsSync49(this.pairsPath))
       return [];
-    const lines = readFileSync41(this.pairsPath, "utf-8").split(`
+    const lines = readFileSync42(this.pairsPath, "utf-8").split(`
 `).filter(Boolean);
     const pairs = lines.map((line) => {
       try {
@@ -510296,14 +510681,14 @@ class PersonalCollector {
     return this.getPairs(userId).length;
   }
   ensureDir() {
-    if (!existsSync48(this.trainingDir)) {
-      mkdirSync32(this.trainingDir, { recursive: true });
+    if (!existsSync49(this.trainingDir)) {
+      mkdirSync33(this.trainingDir, { recursive: true });
     }
   }
   loadStats() {
     try {
-      if (existsSync48(this.statsPath)) {
-        return JSON.parse(readFileSync41(this.statsPath, "utf-8"));
+      if (existsSync49(this.statsPath)) {
+        return JSON.parse(readFileSync42(this.statsPath, "utf-8"));
       }
     } catch {}
     return {
@@ -510315,7 +510700,7 @@ class PersonalCollector {
   }
   saveStats() {
     this.ensureDir();
-    writeFileSync25(this.statsPath, JSON.stringify(this.stats, null, 2));
+    writeFileSync26(this.statsPath, JSON.stringify(this.stats, null, 2));
   }
 }
 var init_personal_collector = () => {};
@@ -510325,7 +510710,7 @@ var exports_manager = {};
 __export(exports_manager, {
   KernelManager: () => KernelManager
 });
-import { existsSync as existsSync49, readFileSync as readFileSync42 } from "fs";
+import { existsSync as existsSync50, readFileSync as readFileSync43 } from "fs";
 import { resolve as resolve12 } from "path";
 
 class KernelManager {
@@ -510339,11 +510724,11 @@ class KernelManager {
   }
   static fromProjectConfig(projectRoot = process.cwd()) {
     const configPath = resolve12(projectRoot, ".8gent/config.json");
-    if (!existsSync49(configPath)) {
+    if (!existsSync50(configPath)) {
       return new KernelManager;
     }
     try {
-      const config2 = JSON.parse(readFileSync42(configPath, "utf-8"));
+      const config2 = JSON.parse(readFileSync43(configPath, "utf-8"));
       const mc = config2.training_proxy ?? {};
       return new KernelManager({
         enabled: mc.enabled ?? false,
@@ -510480,15 +510865,15 @@ var init_reporting = __esm(() => {
 
 // packages/self-autonomy/evolution-db.ts
 import { Database as Database4 } from "bun:sqlite";
-import * as fs40 from "fs";
-import * as os28 from "os";
-import * as path40 from "path";
+import * as fs41 from "fs";
+import * as os29 from "os";
+import * as path41 from "path";
 function getDbPath() {
-  const base2 = process.env.EIGHT_DATA_DIR || path40.join(os28.homedir(), ".8gent");
-  const dir = path40.join(base2, "evolution");
-  if (!fs40.existsSync(dir))
-    fs40.mkdirSync(dir, { recursive: true });
-  return path40.join(dir, "evolution.db");
+  const base2 = process.env.EIGHT_DATA_DIR || path41.join(os29.homedir(), ".8gent");
+  const dir = path41.join(base2, "evolution");
+  if (!fs41.existsSync(dir))
+    fs41.mkdirSync(dir, { recursive: true });
+  return path41.join(dir, "evolution.db");
 }
 function getDb() {
   if (_db)
@@ -510703,8 +511088,8 @@ var init_learned_skills = __esm(() => {
 
 // packages/self-autonomy/index.ts
 import { execSync as execSync3 } from "child_process";
-import * as fs41 from "fs";
-import * as path41 from "path";
+import * as fs42 from "fs";
+import * as path42 from "path";
 
 class AutoGit {
   cwd;
@@ -510830,7 +511215,7 @@ class SelfHeal {
   constructor(workingDirectory, verbose = false) {
     this.cwd = workingDirectory;
     this.verbose = verbose;
-    this.memoryPath = path41.join(workingDirectory, ".8gent", "context", "healing.json");
+    this.memoryPath = path42.join(workingDirectory, ".8gent", "context", "healing.json");
     this.memory = this.loadMemory();
   }
   log(message) {
@@ -510840,18 +511225,18 @@ class SelfHeal {
   }
   loadMemory() {
     try {
-      if (fs41.existsSync(this.memoryPath)) {
-        return JSON.parse(fs41.readFileSync(this.memoryPath, "utf-8"));
+      if (fs42.existsSync(this.memoryPath)) {
+        return JSON.parse(fs42.readFileSync(this.memoryPath, "utf-8"));
       }
     } catch {}
     return { patterns: {} };
   }
   saveMemory() {
-    const dir = path41.dirname(this.memoryPath);
-    if (!fs41.existsSync(dir)) {
-      fs41.mkdirSync(dir, { recursive: true });
+    const dir = path42.dirname(this.memoryPath);
+    if (!fs42.existsSync(dir)) {
+      fs42.mkdirSync(dir, { recursive: true });
     }
-    fs41.writeFileSync(this.memoryPath, JSON.stringify(this.memory, null, 2));
+    fs42.writeFileSync(this.memoryPath, JSON.stringify(this.memory, null, 2));
   }
   getKnownSolution(errorPattern) {
     const pattern = this.memory.patterns[errorPattern];
@@ -510930,7 +511315,7 @@ class SessionMemory {
   verbose;
   constructor(workingDirectory, verbose = false) {
     this.cwd = workingDirectory;
-    this.contextPath = path41.join(workingDirectory, ".8gent", "context");
+    this.contextPath = path42.join(workingDirectory, ".8gent", "context");
     this.verbose = verbose;
   }
   log(message) {
@@ -510939,15 +511324,15 @@ class SessionMemory {
     }
   }
   ensureDirectories() {
-    if (!fs41.existsSync(this.contextPath)) {
-      fs41.mkdirSync(this.contextPath, { recursive: true });
+    if (!fs42.existsSync(this.contextPath)) {
+      fs42.mkdirSync(this.contextPath, { recursive: true });
     }
   }
   getWorkingContext() {
-    const contextFile = path41.join(this.contextPath, "working.json");
+    const contextFile = path42.join(this.contextPath, "working.json");
     try {
-      if (fs41.existsSync(contextFile)) {
-        const context3 = JSON.parse(fs41.readFileSync(contextFile, "utf-8"));
+      if (fs42.existsSync(contextFile)) {
+        const context3 = JSON.parse(fs42.readFileSync(contextFile, "utf-8"));
         const started = new Date(context3.started);
         const now2 = new Date;
         const hoursDiff = (now2.getTime() - started.getTime()) / (1000 * 60 * 60);
@@ -510961,12 +511346,12 @@ class SessionMemory {
   }
   saveWorkingContext(context3) {
     this.ensureDirectories();
-    const contextFile = path41.join(this.contextPath, "working.json");
-    fs41.writeFileSync(contextFile, JSON.stringify(context3, null, 2));
+    const contextFile = path42.join(this.contextPath, "working.json");
+    fs42.writeFileSync(contextFile, JSON.stringify(context3, null, 2));
     this.log("Saved working context");
   }
   logEvolution(entry) {
-    const logFile = path41.join(this.cwd, ".8gent", "evolution.log");
+    const logFile = path42.join(this.cwd, ".8gent", "evolution.log");
     const line = `[${entry.timestamp}] ${entry.action} ${entry.file}
 ` + `  REASON: ${entry.reason}
 ` + `  RESULT: ${entry.result}
@@ -510974,7 +511359,7 @@ class SessionMemory {
 ` + `  MERGED: ${entry.merged}
 
 `;
-    fs41.appendFileSync(logFile, line);
+    fs42.appendFileSync(logFile, line);
     this.log(`Evolution: ${entry.action} ${entry.file} \u2192 ${entry.result}`);
   }
 }
@@ -511007,7 +511392,7 @@ class SelfAutonomy {
     this.memory.saveWorkingContext({
       session: `sess_${Date.now()}`,
       started: new Date().toISOString(),
-      project: path41.basename(this.config.workingDirectory),
+      project: path42.basename(this.config.workingDirectory),
       branch: this.currentBranch,
       activeFiles: [],
       currentTask: taskDescription,
@@ -511464,9 +511849,9 @@ var init_heartbeat = __esm(() => {
 });
 
 // packages/specifications/session/writer.ts
-import * as fs42 from "fs";
-import * as os29 from "os";
-import * as path42 from "path";
+import * as fs43 from "fs";
+import * as os30 from "os";
+import * as path43 from "path";
 
 class SessionWriter {
   filePath;
@@ -511489,16 +511874,16 @@ class SessionWriter {
     this.sessionId = sessionId;
     this.startTime = Date.now();
     const dir = sessionsDir || SESSIONS_DIR2;
-    if (!fs42.existsSync(dir)) {
-      fs42.mkdirSync(dir, { recursive: true });
+    if (!fs43.existsSync(dir)) {
+      fs43.mkdirSync(dir, { recursive: true });
     }
-    this.filePath = path42.join(dir, `${sessionId}.jsonl`);
-    this.fd = fs42.openSync(this.filePath, "a");
+    this.filePath = path43.join(dir, `${sessionId}.jsonl`);
+    this.fd = fs43.openSync(this.filePath, "a");
   }
   write(entry) {
     const line = `${JSON.stringify(entry)}
 `;
-    fs42.writeSync(this.fd, line);
+    fs43.writeSync(this.fd, line);
   }
   nextSeq() {
     return this.seq++;
@@ -511689,7 +512074,7 @@ class SessionWriter {
         reportId: reportId ?? null
       }
     });
-    fs42.closeSync(this.fd);
+    fs43.closeSync(this.fd);
   }
   getFilePath() {
     return this.filePath;
@@ -511728,18 +512113,18 @@ class SessionWriter {
 }
 var SESSIONS_DIR2;
 var init_writer = __esm(() => {
-  SESSIONS_DIR2 = path42.join(os29.homedir(), ".8gent", "sessions");
+  SESSIONS_DIR2 = path43.join(os30.homedir(), ".8gent", "sessions");
 });
 
 // packages/eight/compaction.ts
 class FileTracker {
   read = new Set;
   modified = new Set;
-  trackRead(path43) {
-    this.read.add(path43);
+  trackRead(path44) {
+    this.read.add(path44);
   }
-  trackModified(path43) {
-    this.modified.add(path43);
+  trackModified(path44) {
+    this.modified.add(path44);
   }
   merge(other) {
     Array.from(other.read).forEach((p) => this.read.add(p));
@@ -512123,7 +512508,7 @@ __export(exports_mapper, {
   RepoMapper: () => RepoMapper
 });
 import { readFile, readdir, stat } from "fs/promises";
-import { basename as basename9, extname as extname8, join as join57, relative as relative3 } from "path";
+import { basename as basename9, extname as extname8, join as join58, relative as relative3 } from "path";
 
 class RepoMapper {
   files = new Map;
@@ -512142,7 +512527,7 @@ class RepoMapper {
       return;
     }
     for (const e3 of entries) {
-      const full = join57(dir, e3.name);
+      const full = join58(dir, e3.name);
       if (SKIP.test(e3.name))
         continue;
       if (e3.isDirectory()) {
@@ -512198,8 +512583,8 @@ class RepoMapper {
       if (score > 0.05)
         scored.push({ path: rel, score });
     }
-    return scored.sort((a5, b2) => b2.score - a5.score).slice(0, 20).map(({ path: path43, score }) => ({
-      path: path43,
+    return scored.sort((a5, b2) => b2.score - a5.score).slice(0, 20).map(({ path: path44, score }) => ({
+      path: path44,
       score,
       content: "",
       mode: "full"
@@ -512225,7 +512610,7 @@ class RepoMapper {
         continue;
       let content;
       try {
-        content = await readFile(join57(this.root, file2.path), "utf-8");
+        content = await readFile(join58(this.root, file2.path), "utf-8");
       } catch {
         continue;
       }
@@ -512276,15 +512661,15 @@ var init_repo_context = __esm(() => {
 });
 
 // packages/eight/instruction-loader.ts
-import { existsSync as existsSync53, readFileSync as readFileSync44 } from "fs";
-import { homedir as homedir31 } from "os";
-import { dirname as dirname21, join as join58, resolve as resolve13 } from "path";
+import { existsSync as existsSync54, readFileSync as readFileSync45 } from "fs";
+import { homedir as homedir32 } from "os";
+import { dirname as dirname21, join as join59, resolve as resolve13 } from "path";
 function findInstructionFile(dir) {
   for (const filename of INSTRUCTION_FILES) {
-    const filePath = join58(dir, filename);
-    if (existsSync53(filePath)) {
+    const filePath = join59(dir, filename);
+    if (existsSync54(filePath)) {
       try {
-        return readFileSync44(filePath, "utf-8");
+        return readFileSync45(filePath, "utf-8");
       } catch {}
     }
   }
@@ -512308,7 +512693,7 @@ function walkUp(startDir) {
 }
 function loadInstructions(cwd) {
   const parts = [];
-  const globalDir = join58(homedir31(), ".8gent");
+  const globalDir = join59(homedir32(), ".8gent");
   const globalContent = findInstructionFile(globalDir);
   if (globalContent) {
     parts.push(globalContent.trim());
@@ -512802,9 +513187,9 @@ var require_windowsPtyAgent = __commonJS((exports) => {
   var __dirname = "/Users/jamesspalding/8gent-code/node_modules/node-pty/lib";
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.argsToCommandLine = exports.WindowsPtyAgent = undefined;
-  var fs43 = __require("fs");
-  var os30 = __require("os");
-  var path43 = __require("path");
+  var fs44 = __require("fs");
+  var os31 = __require("os");
+  var path44 = __require("path");
   var child_process_1 = __require("child_process");
   var net_1 = __require("net");
   var windowsConoutConnection_1 = require_windowsConoutConnection();
@@ -512838,7 +513223,7 @@ var require_windowsPtyAgent = __commonJS((exports) => {
         }
       }
       this._ptyNative = this._useConpty ? conptyNative : winptyNative;
-      cwd = path43.resolve(cwd);
+      cwd = path44.resolve(cwd);
       var commandLine = argsToCommandLine(file2, args);
       var term;
       if (this._useConpty) {
@@ -512859,7 +513244,7 @@ var require_windowsPtyAgent = __commonJS((exports) => {
       this._outSocket.on("connect", function() {
         _this._outSocket.emit("ready_datapipe");
       });
-      var inSocketFD = fs43.openSync(term.conin, "w");
+      var inSocketFD = fs44.openSync(term.conin, "w");
       this._inSocket = new net_1.Socket({
         fd: inSocketFD,
         readable: false,
@@ -512958,7 +513343,7 @@ var require_windowsPtyAgent = __commonJS((exports) => {
     WindowsPtyAgent2.prototype._getConsoleProcessList = function() {
       var _this = this;
       return new Promise(function(resolve14) {
-        var agent = child_process_1.fork(path43.join(__dirname, "conpty_console_list_agent"), [_this._innerPid.toString()]);
+        var agent = child_process_1.fork(path44.join(__dirname, "conpty_console_list_agent"), [_this._innerPid.toString()]);
         agent.on("message", function(message) {
           clearTimeout(timeout);
           resolve14(message.consoleProcessList);
@@ -512981,7 +513366,7 @@ var require_windowsPtyAgent = __commonJS((exports) => {
       configurable: true
     });
     WindowsPtyAgent2.prototype._getWindowsBuildNumber = function() {
-      var osVersion = /(\d+)\.(\d+)\.(\d+)/g.exec(os30.release());
+      var osVersion = /(\d+)\.(\d+)\.(\d+)/g.exec(os31.release());
       var buildNumber = 0;
       if (osVersion && osVersion.length === 4) {
         buildNumber = parseInt(osVersion[3]);
@@ -513286,15 +513671,15 @@ var require_unixTerminal = __commonJS((exports) => {
   }();
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.UnixTerminal = undefined;
-  var fs43 = __require("fs");
-  var path43 = __require("path");
+  var fs44 = __require("fs");
+  var path44 = __require("path");
   var tty = __require("tty");
   var terminal_1 = require_terminal();
   var utils_1 = require_utils11();
   var native = utils_1.loadNativeModule("pty");
   var pty = native.module;
   var helperPath = native.dir + "/spawn-helper";
-  helperPath = path43.resolve(__dirname, helperPath);
+  helperPath = path44.resolve(__dirname, helperPath);
   helperPath = helperPath.replace("app.asar", "app.asar.unpacked");
   helperPath = helperPath.replace("node_modules.asar", "node_modules.asar.unpacked");
   var DEFAULT_FILE = "sh";
@@ -513538,7 +513923,7 @@ var require_unixTerminal = __commonJS((exports) => {
         return;
       }
       var task = this._writeQueue[0];
-      fs43.write(this._fd, task.buffer, task.offset, function(err, written) {
+      fs44.write(this._fd, task.buffer, task.offset, function(err, written) {
         if (err) {
           if ("code" in err && err.code === "EAGAIN") {
             _this._writeImmediate = setImmediate(function() {
@@ -514552,9 +514937,9 @@ __export(exports_skill_creator, {
   _resetForTests: () => _resetForTests,
   MAX_AUTO_SKILLS_PER_SESSION: () => MAX_AUTO_SKILLS_PER_SESSION
 });
-import * as fs43 from "fs";
-import { homedir as homedir32 } from "os";
-import * as path43 from "path";
+import * as fs44 from "fs";
+import { homedir as homedir33 } from "os";
+import * as path44 from "path";
 function createAutoSkill(spec, context3) {
   if (createdThisSession >= MAX_AUTO_SKILLS_PER_SESSION) {
     return {
@@ -514572,11 +514957,11 @@ function createAutoSkill(spec, context3) {
   if (!spec.body || spec.body.trim().length < 30) {
     return { ok: false, reason: "body-too-short" };
   }
-  const targetDir = path43.join(SKILLS_DIR, safeName);
-  if (!targetDir.startsWith(SKILLS_DIR + path43.sep) && targetDir !== SKILLS_DIR) {
+  const targetDir = path44.join(SKILLS_DIR, safeName);
+  if (!targetDir.startsWith(SKILLS_DIR + path44.sep) && targetDir !== SKILLS_DIR) {
     return { ok: false, reason: "path-traversal-blocked" };
   }
-  if (fs43.existsSync(targetDir)) {
+  if (fs44.existsSync(targetDir)) {
     return { ok: false, reason: "name-collision" };
   }
   const frontmatter = [
@@ -514592,8 +514977,8 @@ function createAutoSkill(spec, context3) {
   const content = `${frontmatter}${spec.body.trim()}
 `;
   try {
-    fs43.mkdirSync(targetDir, { recursive: true });
-    fs43.writeFileSync(path43.join(targetDir, "SKILL.md"), content, "utf-8");
+    fs44.mkdirSync(targetDir, { recursive: true });
+    fs44.writeFileSync(path44.join(targetDir, "SKILL.md"), content, "utf-8");
   } catch (err) {
     return { ok: false, reason: `write-failed: ${err.message}` };
   }
@@ -514602,7 +514987,7 @@ function createAutoSkill(spec, context3) {
     timestamp: new Date().toISOString(),
     sessionId: context3.sessionId,
     name: safeName,
-    path: path43.join(targetDir, "SKILL.md"),
+    path: path44.join(targetDir, "SKILL.md"),
     description: spec.description,
     rationale: spec.rationale ?? null,
     revert
@@ -514638,21 +515023,21 @@ function escapeYamlScalar(s3) {
 }
 function appendLog(entry) {
   try {
-    fs43.mkdirSync(path43.dirname(LOG_FILE), { recursive: true });
-    fs43.appendFileSync(LOG_FILE, `${JSON.stringify(entry)}
+    fs44.mkdirSync(path44.dirname(LOG_FILE), { recursive: true });
+    fs44.appendFileSync(LOG_FILE, `${JSON.stringify(entry)}
 `, "utf-8");
   } catch {}
 }
 var MAX_AUTO_SKILLS_PER_SESSION = 3, REPO_ROOT, SKILLS_DIR, LOG_FILE, createdThisSession = 0;
 var init_skill_creator = __esm(() => {
-  REPO_ROOT = path43.resolve(import.meta.dir, "..", "..");
-  SKILLS_DIR = path43.join(REPO_ROOT, "packages", "skills");
-  LOG_FILE = path43.join(homedir32(), ".8gent", "auto-created-skills.jsonl");
+  REPO_ROOT = path44.resolve(import.meta.dir, "..", "..");
+  SKILLS_DIR = path44.join(REPO_ROOT, "packages", "skills");
+  LOG_FILE = path44.join(homedir33(), ".8gent", "auto-created-skills.jsonl");
 });
 
 // packages/ai/tools.ts
-import * as fs44 from "fs";
-import * as path44 from "path";
+import * as fs45 from "fs";
+import * as path45 from "path";
 function setToolContext(ctx) {
   _ctx = ctx;
 }
@@ -514663,7 +515048,7 @@ function getRuntimeParams() {
   return _runtime;
 }
 function resolvePath(p) {
-  return path44.isAbsolute(p) ? p : path44.join(_ctx.workingDirectory, p);
+  return path45.isAbsolute(p) ? p : path45.join(_ctx.workingDirectory, p);
 }
 async function runShellCommand(command) {
   const { getPermissionManager: getPermissionManager3, isCommandDangerous: isCommandDangerous2 } = await Promise.resolve().then(() => (init_permissions(), exports_permissions));
@@ -514831,7 +515216,8 @@ var init_tools2 = __esm(() => {
     systemPromptLength: 0,
     messageHistoryLength: 0,
     stepCount: 0,
-    appendedContext: []
+    appendedContext: [],
+    voiceChatActive: false
   };
   _runtime = { ...DEFAULT_RUNTIME };
   getOutline = tool({
@@ -514842,7 +515228,7 @@ var init_tools2 = __esm(() => {
     execute: async ({ filePath }) => {
       const { parseTypeScriptFile: parseTypeScriptFile2 } = await Promise.resolve().then(() => (init_typescript_parser(), exports_typescript_parser));
       const absolutePath = resolvePath(filePath);
-      if (!fs44.existsSync(absolutePath))
+      if (!fs45.existsSync(absolutePath))
         return `File not found: ${absolutePath}`;
       try {
         const outline = parseTypeScriptFile2(absolutePath);
@@ -514876,7 +515262,7 @@ var init_tools2 = __esm(() => {
       const filePath = symbolId.slice(0, separatorIndex);
       const symbolName = symbolId.slice(separatorIndex + 2);
       const absolutePath = resolvePath(filePath);
-      if (!fs44.existsSync(absolutePath))
+      if (!fs45.existsSync(absolutePath))
         return `File not found: ${absolutePath}`;
       try {
         const outline = parseTypeScriptFile2(absolutePath);
@@ -514919,7 +515305,7 @@ ${source}`;
               matches.push({
                 name: symbol21.name,
                 kind: symbol21.kind,
-                file: path44.relative(_ctx.workingDirectory, file2),
+                file: path45.relative(_ctx.workingDirectory, file2),
                 line: symbol21.startLine
               });
             }
@@ -514940,9 +515326,9 @@ ${source}`;
     }),
     execute: async ({ path: filePath }) => {
       const absolutePath = resolvePath(filePath);
-      if (!fs44.existsSync(absolutePath))
+      if (!fs45.existsSync(absolutePath))
         return `File not found: ${absolutePath}`;
-      const content = fs44.readFileSync(absolutePath, "utf-8");
+      const content = fs45.readFileSync(absolutePath, "utf-8");
       const lines = content.split(`
 `);
       if (lines.length > 200) {
@@ -514964,10 +515350,10 @@ ${lines.slice(0, 200).join(`
     }),
     execute: async ({ path: filePath, content }) => {
       const absolutePath = resolvePath(filePath);
-      const dir = path44.dirname(absolutePath);
-      if (!fs44.existsSync(dir))
-        fs44.mkdirSync(dir, { recursive: true });
-      fs44.writeFileSync(absolutePath, content);
+      const dir = path45.dirname(absolutePath);
+      if (!fs45.existsSync(dir))
+        fs45.mkdirSync(dir, { recursive: true });
+      fs45.writeFileSync(absolutePath, content);
       return `File written: ${absolutePath}`;
     }
   });
@@ -514980,12 +515366,12 @@ ${lines.slice(0, 200).join(`
     }),
     execute: async ({ path: filePath, oldText, newText }) => {
       const absolutePath = resolvePath(filePath);
-      if (!fs44.existsSync(absolutePath))
+      if (!fs45.existsSync(absolutePath))
         return `File not found: ${absolutePath}`;
-      const content = fs44.readFileSync(absolutePath, "utf-8");
+      const content = fs45.readFileSync(absolutePath, "utf-8");
       if (!content.includes(oldText))
         return `Error: Could not find the text to replace in ${filePath}. Make sure oldText matches exactly.`;
-      fs44.writeFileSync(absolutePath, content.replace(oldText, newText));
+      fs45.writeFileSync(absolutePath, content.replace(oldText, newText));
       return `File edited: ${absolutePath}
 Replaced ${oldText.length} chars with ${newText.length} chars.`;
     }
@@ -515007,7 +515393,7 @@ Replaced ${oldText.length} chars with ${newText.length} chars.`;
       const results = [];
       for (const f3 of files.slice(0, 100)) {
         try {
-          const s3 = await fsStat(path44.join(absolutePath, f3));
+          const s3 = await fsStat(path45.join(absolutePath, f3));
           results.push(s3.isDirectory() ? `${f3}/` : f3);
         } catch {
           results.push(f3);
@@ -515746,16 +516132,16 @@ ${changes.slice(0, 1000)}`;
       append: exports_external.boolean().optional().describe("If true, appends to existing note with same title instead of creating new")
     }),
     execute: async ({ title, content, append: append3 }) => {
-      const { existsSync: existsSync56, mkdirSync: mkdirSync38, readFileSync: readFileSync46, writeFileSync: writeFileSync29 } = await import("fs");
-      const { join: join61 } = await import("path");
-      const dataDir = join61(process.env.HOME || "~", ".8gent", "tabs");
-      const filepath = join61(dataDir, "notes.json");
-      if (!existsSync56(dataDir))
-        mkdirSync38(dataDir, { recursive: true });
+      const { existsSync: existsSync57, mkdirSync: mkdirSync39, readFileSync: readFileSync47, writeFileSync: writeFileSync30 } = await import("fs");
+      const { join: join62 } = await import("path");
+      const dataDir = join62(process.env.HOME || "~", ".8gent", "tabs");
+      const filepath = join62(dataDir, "notes.json");
+      if (!existsSync57(dataDir))
+        mkdirSync39(dataDir, { recursive: true });
       let notes = [];
       try {
-        if (existsSync56(filepath)) {
-          const raw = JSON.parse(readFileSync46(filepath, "utf-8"));
+        if (existsSync57(filepath)) {
+          const raw = JSON.parse(readFileSync47(filepath, "utf-8"));
           notes = raw.notes || [];
         }
       } catch {}
@@ -515785,7 +516171,7 @@ ${content}`;
           updatedAt: now2
         });
       }
-      writeFileSync29(filepath, JSON.stringify({ notes }, null, 2));
+      writeFileSync30(filepath, JSON.stringify({ notes }, null, 2));
       return { ok: true, noteCount: notes.length, title };
     }
   });
@@ -517580,6 +517966,43 @@ var init_vision_interpreter = __esm(() => {
   init_vision_router();
 });
 
+// packages/eight/auto-tune.ts
+function computeAutoTune(settings) {
+  return {
+    liteMode: resolveLiteMode(settings.performance.mode),
+    showIntro: resolveIntroBanner(settings.performance.introBanner),
+    voiceSilenceMs: settings.voice.silenceThresholdMs
+  };
+}
+function resolveLiteMode(mode) {
+  if (mode === "lite")
+    return true;
+  if (mode === "full")
+    return false;
+  if (process.env.CI === "true")
+    return true;
+  if (!process.stdout.isTTY)
+    return true;
+  if (process.env["8GENT_LITE"] === "1")
+    return true;
+  if (process.env["8GENT_FULL"] === "1")
+    return false;
+  return false;
+}
+function resolveIntroBanner(introBanner) {
+  if (introBanner === "on")
+    return true;
+  if (introBanner === "off")
+    return false;
+  if (!process.stdout.isTTY)
+    return false;
+  if (process.env["8GENT_NO_INTRO"] === "1")
+    return false;
+  if (process.env["8GENT_LITE"] === "1")
+    return false;
+  return true;
+}
+
 // packages/proactive/opportunity-scanner.ts
 var init_opportunity_scanner = () => {};
 
@@ -517587,19 +518010,19 @@ var init_opportunity_scanner = () => {};
 var init_capability_matcher = () => {};
 
 // packages/proactive/work-tracker.ts
-import { join as join61 } from "path";
+import { join as join62 } from "path";
 var DATA_DIR2, STORE_PATH;
 var init_work_tracker = __esm(() => {
-  DATA_DIR2 = join61(process.env.HOME || "~", ".8gent");
-  STORE_PATH = join61(DATA_DIR2, "opportunities.json");
+  DATA_DIR2 = join62(process.env.HOME || "~", ".8gent");
+  STORE_PATH = join62(DATA_DIR2, "opportunities.json");
 });
 
 // packages/proactive/revenue-engine.ts
-import { join as join62 } from "path";
+import { join as join63 } from "path";
 var DATA_DIR3, STORE_PATH2;
 var init_revenue_engine = __esm(() => {
-  DATA_DIR3 = join62(process.env.HOME || "~", ".8gent");
-  STORE_PATH2 = join62(DATA_DIR3, "revenue.json");
+  DATA_DIR3 = join63(process.env.HOME || "~", ".8gent");
+  STORE_PATH2 = join63(DATA_DIR3, "revenue.json");
 });
 
 // packages/proactive/deliverable-generator.ts
@@ -517612,11 +518035,11 @@ var init_client_outreach = () => {};
 var init_content_packaging = () => {};
 
 // packages/tools/browser/cache.ts
-import { homedir as homedir33 } from "os";
-import { join as join63 } from "path";
+import { homedir as homedir34 } from "os";
+import { join as join64 } from "path";
 var CACHE_DIR, TTL_MS, MAX_CACHE_BYTES;
 var init_cache2 = __esm(() => {
-  CACHE_DIR = join63(process.env.EIGHT_DATA_DIR || join63(homedir33(), ".8gent"), "browser-cache");
+  CACHE_DIR = join64(process.env.EIGHT_DATA_DIR || join64(homedir34(), ".8gent"), "browser-cache");
   TTL_MS = 60 * 60 * 1000;
   MAX_CACHE_BYTES = 100 * 1024 * 1024;
 });
@@ -518266,7 +518689,7 @@ class Voice {
   }
 }
 var PERSONALITY, GREETINGS, COMPLETION_PHRASES, ERROR_PHRASES, IDLE_QUIPS, THINKING_PHRASES, PROGRESS_PHRASES, voice;
-var init_voice2 = __esm(() => {
+var init_voice3 = __esm(() => {
   PERSONALITY = {
     name: "8gent",
     tagline: "The Infinite Gentleman",
@@ -519236,8 +519659,8 @@ function createOpenAICompatible(options) {
   const getHeaders = () => withUserAgentSuffix(headers, `ai-sdk/openai-compatible/${VERSION4}`);
   const getCommonModelConfig = (modelType) => ({
     provider: `${providerName}.${modelType}`,
-    url: ({ path: path45 }) => {
-      const url2 = new URL(`${baseURL}${path45}`);
+    url: ({ path: path46 }) => {
+      const url2 = new URL(`${baseURL}${path46}`);
       if (options.queryParams) {
         url2.search = new URLSearchParams(options.queryParams).toString();
       }
@@ -520496,14 +520919,14 @@ var init_agent = __esm(() => {
 });
 
 // packages/ai/task-router.ts
-import { join as join64 } from "path";
+import { join as join65 } from "path";
 var CONFIG_DIR2, ROUTER_CONFIG_PATH, ROUTER_STATS_PATH, ClassificationSchema;
 var init_task_router = __esm(() => {
   init_zod();
   init_providers2();
-  CONFIG_DIR2 = join64(process.env.HOME || "~", ".8gent");
-  ROUTER_CONFIG_PATH = join64(CONFIG_DIR2, "router.json");
-  ROUTER_STATS_PATH = join64(CONFIG_DIR2, "router-stats.json");
+  CONFIG_DIR2 = join65(process.env.HOME || "~", ".8gent");
+  ROUTER_CONFIG_PATH = join65(CONFIG_DIR2, "router.json");
+  ROUTER_STATS_PATH = join65(CONFIG_DIR2, "router-stats.json");
   ClassificationSchema = exports_external.object({
     category: exports_external.enum(["code", "reasoning", "simple", "creative"]).describe("Task category: code (write/edit/debug code, fix errors, implement features), " + "reasoning (complex logic, planning, architecture, multi-step analysis), " + "simple (quick answers, explanations, short chat, factual questions), " + "creative (writing, naming, brainstorming, design ideas)"),
     confidence: exports_external.number().min(0).max(1).describe("How confident you are in this classification (0-1)"),
@@ -520517,11 +520940,11 @@ var init_toolshed_bridge = __esm(() => {
 });
 
 // packages/ai/embedding-cache.ts
-import { join as join65 } from "path";
+import { join as join66 } from "path";
 var CACHE_DIR2, CACHE_PATH;
 var init_embedding_cache = __esm(() => {
-  CACHE_DIR2 = join65(process.env.HOME || "~", ".8gent");
-  CACHE_PATH = join65(CACHE_DIR2, "embedding-cache.json");
+  CACHE_DIR2 = join66(process.env.HOME || "~", ".8gent");
+  CACHE_PATH = join66(CACHE_DIR2, "embedding-cache.json");
 });
 
 // packages/ai/edge-inference.ts
@@ -520543,12 +520966,40 @@ var init_ai = __esm(() => {
   init_embedding_cache();
 });
 
+// packages/eight/visualiser-bridge.ts
+var exports_visualiser_bridge = {};
+__export(exports_visualiser_bridge, {
+  setVisualiserTokenSink: () => setVisualiserTokenSink,
+  notifyVisualiserToken: () => notifyVisualiserToken,
+  _hasSink: () => _hasSink
+});
+function setVisualiserTokenSink(next2) {
+  sink = next2;
+}
+function notifyVisualiserToken(text4) {
+  if (!sink || !text4)
+    return;
+  const parts = text4.split(/\s+/).filter(Boolean).slice(0, 24);
+  for (const part of parts) {
+    try {
+      sink(part);
+    } catch {}
+  }
+}
+function _hasSink() {
+  return sink !== null;
+}
+var sink = null;
+
 // packages/eight/agent.ts
 var exports_agent = {};
 __export(exports_agent, {
   Agent: () => Agent
 });
 import * as crypto8 from "crypto";
+import * as fs46 from "fs";
+import * as os31 from "os";
+import * as path46 from "path";
 
 class Agent {
   executor;
@@ -520568,7 +521019,6 @@ class Agent {
   evidenceCollector;
   sessionEvidence = [];
   proactiveGatherer = null;
-  workflowValidator;
   kanban = getKanbanBoard();
   currentBmadTask = null;
   heartbeat;
@@ -520589,6 +521039,8 @@ class Agent {
     this.hookManager = getHookManager();
     this.sessionId = `session_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
     this.sessionStartTime = Date.now();
+    const autoTuneSettings = readSettingsFileSync();
+    const LITE = autoTuneSettings !== null ? computeAutoTune(autoTuneSettings).liteMode : process.env["8GENT_LITE"] === "0" || process.env["8GENT_FULL"] === "1" ? false : true;
     this.hookManager.setWorkingDirectory(config2.workingDirectory || process.cwd());
     setToolContext({
       workingDirectory: config2.workingDirectory || process.cwd()
@@ -520596,24 +521048,23 @@ class Agent {
     this.toolRegistry = new ToolRegistry(config2.allTools ?? false);
     this.compaction = new ProactiveCompression;
     const cwd = config2.workingDirectory || process.cwd();
-    indexFolder(cwd).then((index2) => {
-      console.log(`[AST] Indexed ${index2.fileCount} files, ${index2.symbolCount} symbols`);
-    }).catch(() => {});
+    if (!LITE) {
+      indexFolder(cwd).then((index2) => {
+        if (process.env.DEBUG === "1") {
+          console.log(`[AST] Indexed ${index2.fileCount} files, ${index2.symbolCount} symbols`);
+        }
+      }).catch(() => {});
+    }
     this.planner = getProactivePlanner();
     this.evidenceCollector = new EvidenceCollector({
       workingDirectory: config2.workingDirectory || process.cwd()
     });
-    this.workflowValidator = new PlanValidateLoop({
-      workingDirectory: config2.workingDirectory || process.cwd(),
-      maxRetries: 2,
-      validateEachStep: true,
-      collectEvidence: true,
-      abortOnFailure: false
-    });
     this.onboarding = new OnboardingManager(config2.workingDirectory || process.cwd());
     if (this.onboarding.needsOnboarding()) {
       this.onboarding.detectIntegrations().catch(() => {});
-      console.log("[8gent] First run detected \u2014 onboarding available. The agent can ask setup questions.");
+      if (process.env.DEBUG === "1") {
+        console.log("[8gent] First run detected - onboarding available. The agent can ask setup questions.");
+      }
     }
     const basePrompt = config2.systemPrompt || DEFAULT_SYSTEM_PROMPT;
     const languageInstruction = this.getLanguageInstruction();
@@ -520682,11 +521133,15 @@ ${buildToolCatalogSegment({ concise: true })}`;
       agent: agentInfo,
       environment: env
     });
-    const syncEnabled = this._readSyncToConvex();
+    const syncEnabled = LITE ? false : this._readSyncToConvex();
     this.sessionSync = new SessionSyncManager(syncEnabled);
-    this.sessionSync.startSession(config2.model, config2.runtime, config2.workingDirectory).catch(() => {});
+    if (!LITE && syncEnabled) {
+      this.sessionSync.startSession(config2.model, config2.runtime, config2.workingDirectory).catch(() => {});
+    }
     this.kernel = KernelManager.fromProjectConfig(config2.workingDirectory || process.cwd());
-    this.kernel.start().catch(() => {});
+    if (!LITE) {
+      this.kernel.start().catch(() => {});
+    }
     this.orchestratorBus = getOrchestratorBus();
     import("child_process").then(({ exec: exec4 }) => {
       exec4("git rev-parse --abbrev-ref HEAD", { cwd, timeout: 2000 }, (err, stdout) => {
@@ -520712,8 +521167,10 @@ ${buildToolCatalogSegment({ concise: true })}`;
       workingDirectory: config2.workingDirectory || process.cwd(),
       verbose: false
     });
-    this.heartbeat.start();
-    this.heartbeat.updateContext({ currentTask: "Agent initialized" });
+    if (!LITE) {
+      this.heartbeat.start();
+      this.heartbeat.updateContext({ currentTask: "Agent initialized" });
+    }
     const vault = getVault();
     if (vault.has("TELEGRAM_BOT_TOKEN") && !getActiveTelegramBot()) {
       const telegramToken = vault.get("TELEGRAM_BOT_TOKEN");
@@ -520722,7 +521179,9 @@ ${buildToolCatalogSegment({ concise: true })}`;
         startTelegramBot(telegramToken, this, {
           allowedUsers: chatId ? [Number.parseInt(chatId, 10)] : undefined
         }).catch((err) => {
-          console.log(`[8gent] Telegram auto-start failed: ${err.message}`);
+          if (process.env.DEBUG === "1") {
+            console.log(`[8gent] Telegram auto-start failed: ${err.message}`);
+          }
         });
       }
     }
@@ -520734,10 +521193,14 @@ ${buildToolCatalogSegment({ concise: true })}`;
         for (const [name21, fn] of Object.entries(extTools)) {
           this.toolRegistry.registerExternalTool(name21, fn);
         }
-        console.log(`[ext] ${loaded.length} extension(s), ${Object.keys(extTools).length} tool(s) registered`);
+        if (process.env.DEBUG === "1") {
+          console.log(`[ext] ${loaded.length} extension(s), ${Object.keys(extTools).length} tool(s) registered`);
+        }
       }
     }).catch((err) => {
-      console.log(`[ext] Extension loading failed: ${err}`);
+      if (process.env.DEBUG === "1") {
+        console.log(`[ext] Extension loading failed: ${err}`);
+      }
     });
   }
   async chat(userMessage, imageBase64, imageMimeType) {
@@ -520872,6 +521335,12 @@ Ask the user naturally \u2014 don't mention this system instruction. After they
 ## Agent Self-Appended Context
 ${tunedParams.appendedContext.map((c3, i4) => `[${i4 + 1}] ${c3}`).join(`
 `)}`;
+    }
+    if (tunedParams.voiceChatActive) {
+      effectiveInstructions += `
+
+## Voice Chat Mode (active)
+You are in a real-time voice conversation. The user is speaking to you; their words arrive as transcribed text (STT). Your written replies are spoken back to them via text-to-speech (TTS). You are NOT a text-only interface \u2014 you can hear them and they can hear you. Speak conversationally as if on a phone call. Do not apologise for being text-only or claim you cannot hear them \u2014 you can. Keep replies concise and natural since they will be spoken aloud. Avoid heavy markdown, code blocks, or long URLs \u2014 they don't read well in TTS.`;
     }
     let agentConfig = {
       provider: providerConfig,
@@ -521053,6 +521522,10 @@ Do NOT repeat the same fix again.`
           stepCount,
           messageHistoryLength: this.messageHistory.length
         });
+        try {
+          const { notifyVisualiserToken: notifyVisualiserToken2 } = await Promise.resolve().then(() => exports_visualiser_bridge);
+          notifyVisualiserToken2(event.text);
+        } catch {}
         this.events.onStepFinish?.({
           stepNumber: event.stepNumber,
           finishReason: event.finishReason,
@@ -521474,11 +521947,11 @@ ${summary || "  (no provider errors recorded)"}`);
   }
   _readSyncToConvex() {
     try {
-      const fs45 = __require("fs");
-      const path45 = __require("path");
+      const fs47 = __require("fs");
+      const path47 = __require("path");
       const cwd = this.config.workingDirectory || process.cwd();
-      const configPath = path45.join(cwd, ".8gent", "config.json");
-      const raw = fs45.readFileSync(configPath, "utf-8");
+      const configPath = path47.join(cwd, ".8gent", "config.json");
+      const raw = fs47.readFileSync(configPath, "utf-8");
       const config2 = JSON.parse(raw);
       if (typeof config2.syncToConvex === "boolean")
         return config2.syncToConvex;
@@ -521528,6 +522001,21 @@ ${summary || "  (no provider errors recorded)"}`);
     await manager.stopAll();
   }
 }
+function readSettingsFileSync() {
+  try {
+    const file2 = path46.join(os31.homedir(), ".8gent", "settings.json");
+    if (!fs46.existsSync(file2))
+      return null;
+    const raw = fs46.readFileSync(file2, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && parsed.performance && typeof parsed.performance.mode === "string" && typeof parsed.performance.introBanner === "string" && parsed.voice && typeof parsed.voice.silenceThresholdMs === "number") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
 var init_agent2 = __esm(() => {
   init_ast_index();
   init_extensions();
@@ -521555,7 +522043,7 @@ var init_agent2 = __esm(() => {
   init_vision_interpreter();
   init_proactive();
   init_brand();
-  init_voice2();
+  init_voice3();
   init_workflow();
   init_ai();
 });
@@ -521731,8 +522219,8 @@ __export(exports_cli, {
   runCLI: () => runCLI,
   parseCLIArgs: () => parseCLIArgs
 });
-import * as fs45 from "fs";
-import * as path45 from "path";
+import * as fs47 from "fs";
+import * as path47 from "path";
 function parseCLIArgs(args) {
   if (!args.includes("--cli"))
     return null;
@@ -521787,11 +522275,11 @@ function extractCode(text4) {
   return null;
 }
 function writeOutput(filePath, content) {
-  const existed = fs45.existsSync(filePath);
-  const dir = path45.dirname(filePath);
-  if (!fs45.existsSync(dir))
-    fs45.mkdirSync(dir, { recursive: true });
-  fs45.writeFileSync(filePath, content, "utf-8");
+  const existed = fs47.existsSync(filePath);
+  const dir = path47.dirname(filePath);
+  if (!fs47.existsSync(dir))
+    fs47.mkdirSync(dir, { recursive: true });
+  fs47.writeFileSync(filePath, content, "utf-8");
   if (existed) {
     filesModified.push(filePath);
   } else {
@@ -521878,14 +522366,14 @@ __export(exports_session_manager, {
   SessionManager: () => SessionManager
 });
 import { randomUUID as randomUUID4 } from "crypto";
-import * as fs46 from "fs";
-import * as path46 from "path";
+import * as fs48 from "fs";
+import * as path48 from "path";
 
 class SessionManager {
   dir;
   constructor(dataDir) {
-    this.dir = dataDir || path46.join(process.env.HOME || "~", ".8gent", "sessions");
-    fs46.mkdirSync(this.dir, { recursive: true });
+    this.dir = dataDir || path48.join(process.env.HOME || "~", ".8gent", "sessions");
+    fs48.mkdirSync(this.dir, { recursive: true });
   }
   create(opts) {
     const now2 = new Date().toISOString();
@@ -521945,14 +522433,14 @@ class SessionManager {
     this.write(id, file2);
   }
   filePath(id) {
-    return path46.join(this.dir, `${id}.json`);
+    return path48.join(this.dir, `${id}.json`);
   }
   write(id, data2) {
-    fs46.writeFileSync(this.filePath(id), JSON.stringify(data2, null, 2));
+    fs48.writeFileSync(this.filePath(id), JSON.stringify(data2, null, 2));
   }
   readFile(id) {
     try {
-      const raw = fs46.readFileSync(this.filePath(id), "utf-8");
+      const raw = fs48.readFileSync(this.filePath(id), "utf-8");
       return JSON.parse(raw);
     } catch {
       return null;
@@ -521960,11 +522448,11 @@ class SessionManager {
   }
   listAll() {
     try {
-      const files = fs46.readdirSync(this.dir).filter((f3) => f3.endsWith(".json"));
+      const files = fs48.readdirSync(this.dir).filter((f3) => f3.endsWith(".json"));
       const sessions2 = [];
       for (const f3 of files) {
         try {
-          const raw = fs46.readFileSync(path46.join(this.dir, f3), "utf-8");
+          const raw = fs48.readFileSync(path48.join(this.dir, f3), "utf-8");
           const parsed = JSON.parse(raw);
           const { messages: _4, ...info3 } = parsed;
           sessions2.push(info3);
@@ -522267,8 +522755,8 @@ __export(exports_companion, {
   formatDeckSummary: () => formatDeckSummary,
   endSession: () => endSession
 });
-import { existsSync as existsSync57, mkdirSync as mkdirSync40, readFileSync as readFileSync47, writeFileSync as writeFileSync31 } from "fs";
-import { join as join67 } from "path";
+import { existsSync as existsSync59, mkdirSync as mkdirSync41, readFileSync as readFileSync49, writeFileSync as writeFileSync32 } from "fs";
+import { join as join69 } from "path";
 function seedRng(seed) {
   let h2 = 0;
   for (let i4 = 0;i4 < seed.length; i4++) {
@@ -522406,13 +522894,13 @@ function generateCompanion(sessionId) {
 }
 function getDeckPath() {
   const home = process.env.HOME || process.env.USERPROFILE || "~";
-  return join67(home, ".8gent", "companion-deck.json");
+  return join69(home, ".8gent", "companion-deck.json");
 }
 function loadDeck() {
   const deckPath = getDeckPath();
   try {
-    if (existsSync57(deckPath)) {
-      return JSON.parse(readFileSync47(deckPath, "utf-8"));
+    if (existsSync59(deckPath)) {
+      return JSON.parse(readFileSync49(deckPath, "utf-8"));
     }
   } catch {}
   return {
@@ -522429,9 +522917,9 @@ function loadDeck() {
 }
 function saveDeck(deck) {
   const deckPath = getDeckPath();
-  const dir = join67(process.env.HOME || "~", ".8gent");
-  mkdirSync40(dir, { recursive: true });
-  writeFileSync31(deckPath, JSON.stringify(deck, null, 2));
+  const dir = join69(process.env.HOME || "~", ".8gent");
+  mkdirSync41(dir, { recursive: true });
+  writeFileSync32(deckPath, JSON.stringify(deck, null, 2));
 }
 function registerCompanion(sessionId, companion, model) {
   const deck = loadDeck();
@@ -524715,9 +525203,9 @@ function formatDeviceFlowStatus(state) {
 
 // packages/auth/github.ts
 import * as crypto9 from "crypto";
-import * as fs47 from "fs";
-import * as os30 from "os";
-import * as path47 from "path";
+import * as fs49 from "fs";
+import * as os32 from "os";
+import * as path49 from "path";
 async function persistToken(token) {
   cachedToken = token;
   if (process.platform === "darwin") {
@@ -524813,10 +525301,10 @@ async function runSecurity(args) {
   }
 }
 function getFilePath() {
-  return path47.join(os30.homedir(), ".8gent", GITHUB_TOKEN_FILE);
+  return path49.join(os32.homedir(), ".8gent", GITHUB_TOKEN_FILE);
 }
 function deriveKey2() {
-  const fingerprint = `${os30.hostname()}:${os30.userInfo().username}`;
+  const fingerprint = `${os32.hostname()}:${os32.userInfo().username}`;
   return crypto9.pbkdf2Sync(fingerprint, GITHUB_KEY_SALT, 1e5, 32, "sha256");
 }
 function fileStore(token) {
@@ -524833,17 +525321,17 @@ function fileStore(token) {
     ciphertext
   };
   const filePath = getFilePath();
-  const dir = path47.dirname(filePath);
-  if (!fs47.existsSync(dir))
-    fs47.mkdirSync(dir, { recursive: true });
-  fs47.writeFileSync(filePath, JSON.stringify(envelope), { mode: 384 });
+  const dir = path49.dirname(filePath);
+  if (!fs49.existsSync(dir))
+    fs49.mkdirSync(dir, { recursive: true });
+  fs49.writeFileSync(filePath, JSON.stringify(envelope), { mode: 384 });
 }
 function fileRetrieve() {
   const filePath = getFilePath();
-  if (!fs47.existsSync(filePath))
+  if (!fs49.existsSync(filePath))
     return null;
   try {
-    const raw = fs47.readFileSync(filePath, "utf-8");
+    const raw = fs49.readFileSync(filePath, "utf-8");
     const envelope = JSON.parse(raw);
     if (envelope.version !== 1)
       return null;
@@ -524860,8 +525348,8 @@ function fileRetrieve() {
 }
 function fileClear() {
   const filePath = getFilePath();
-  if (fs47.existsSync(filePath))
-    fs47.unlinkSync(filePath);
+  if (fs49.existsSync(filePath))
+    fs49.unlinkSync(filePath);
 }
 async function fetchGitHubUser(token) {
   try {
@@ -524968,9 +525456,9 @@ var init_github = __esm(() => {
 
 // packages/auth/token-store.ts
 import * as crypto10 from "crypto";
-import * as fs48 from "fs";
-import * as os31 from "os";
-import * as path48 from "path";
+import * as fs50 from "fs";
+import * as os33 from "os";
+import * as path50 from "path";
 function getTokenStore() {
   if (process.platform === "darwin") {
     return new KeychainTokenStore;
@@ -525070,7 +525558,7 @@ class EncryptedFileTokenStore {
   filePath;
   key;
   constructor(filePath) {
-    this.filePath = filePath ?? path48.join(os31.homedir(), ".8gent", TOKEN_FILE_NAME);
+    this.filePath = filePath ?? path50.join(os33.homedir(), ".8gent", TOKEN_FILE_NAME);
     this.key = this.deriveKey();
   }
   async store(token) {
@@ -525086,19 +525574,19 @@ class EncryptedFileTokenStore {
       tag: tag2.toString("hex"),
       ciphertext
     };
-    const dir = path48.dirname(this.filePath);
-    if (!fs48.existsSync(dir)) {
-      fs48.mkdirSync(dir, { recursive: true });
+    const dir = path50.dirname(this.filePath);
+    if (!fs50.existsSync(dir)) {
+      fs50.mkdirSync(dir, { recursive: true });
     }
-    fs48.writeFileSync(this.filePath, JSON.stringify(envelope), {
+    fs50.writeFileSync(this.filePath, JSON.stringify(envelope), {
       mode: 384
     });
   }
   async retrieve() {
-    if (!fs48.existsSync(this.filePath))
+    if (!fs50.existsSync(this.filePath))
       return null;
     try {
-      const raw = fs48.readFileSync(this.filePath, "utf-8");
+      const raw = fs50.readFileSync(this.filePath, "utf-8");
       const envelope = JSON.parse(raw);
       if (envelope.version !== 1)
         return null;
@@ -525113,15 +525601,15 @@ class EncryptedFileTokenStore {
     }
   }
   async clear() {
-    if (fs48.existsSync(this.filePath)) {
-      fs48.unlinkSync(this.filePath);
+    if (fs50.existsSync(this.filePath)) {
+      fs50.unlinkSync(this.filePath);
     }
   }
   async exists() {
-    return fs48.existsSync(this.filePath);
+    return fs50.existsSync(this.filePath);
   }
   deriveKey() {
-    const fingerprint = `${os31.hostname()}:${os31.userInfo().username}`;
+    const fingerprint = `${os33.hostname()}:${os33.userInfo().username}`;
     return crypto10.pbkdf2Sync(fingerprint, KEY_DERIVATION_SALT, 1e5, 32, "sha256");
   }
 }
@@ -525299,8 +525787,8 @@ async function runCLIAuthFlow(webBaseUrl = "https://8gent.app", callbacks, timeo
 var init_cli_auth_server = () => {};
 
 // packages/auth/github-tools.ts
-import * as fs49 from "fs";
-import * as path49 from "path";
+import * as fs51 from "fs";
+import * as path51 from "path";
 function githubHeaders(token) {
   return {
     Authorization: `Bearer ${token}`,
@@ -525324,11 +525812,11 @@ async function listRepos(token, opts) {
 }
 async function getCurrentRepoInfo(cwd) {
   const dir = cwd ?? process.cwd();
-  const gitConfigPath = path49.join(dir, ".git", "config");
-  if (!fs49.existsSync(gitConfigPath))
+  const gitConfigPath = path51.join(dir, ".git", "config");
+  if (!fs51.existsSync(gitConfigPath))
     return null;
   try {
-    const config2 = fs49.readFileSync(gitConfigPath, "utf-8");
+    const config2 = fs51.readFileSync(gitConfigPath, "utf-8");
     const remoteMatch = config2.match(/\[remote "origin"\][^[]*url\s*=\s*(.+)/m);
     if (!remoteMatch)
       return null;
@@ -525453,13 +525941,13 @@ var init_github_tools = () => {};
 
 // packages/auth/proxy-provider.ts
 import * as crypto11 from "crypto";
-import * as fs50 from "fs";
-import * as os32 from "os";
-import * as path50 from "path";
+import * as fs52 from "fs";
+import * as os34 from "os";
+import * as path52 from "path";
 function ensureDataDir() {
-  const dir = path50.join(os32.homedir(), ".8gent");
-  if (!fs50.existsSync(dir)) {
-    fs50.mkdirSync(dir, { recursive: true });
+  const dir = path52.join(os34.homedir(), ".8gent");
+  if (!fs52.existsSync(dir)) {
+    fs52.mkdirSync(dir, { recursive: true });
   }
 }
 function generateVesselId() {
@@ -525467,8 +525955,8 @@ function generateVesselId() {
 }
 function loadProxyConfig() {
   try {
-    if (fs50.existsSync(AUTH_CONFIG_PATH)) {
-      const data2 = JSON.parse(fs50.readFileSync(AUTH_CONFIG_PATH, "utf-8"));
+    if (fs52.existsSync(AUTH_CONFIG_PATH)) {
+      const data2 = JSON.parse(fs52.readFileSync(AUTH_CONFIG_PATH, "utf-8"));
       return {
         proxyUrl: data2.proxyUrl || DEFAULT_PROXY_URL,
         vesselId: data2.vesselId || generateVesselId()
@@ -525484,7 +525972,7 @@ function loadProxyConfig() {
 }
 function saveProxyConfig(config2) {
   ensureDataDir();
-  fs50.writeFileSync(AUTH_CONFIG_PATH, JSON.stringify(config2, null, 2), {
+  fs52.writeFileSync(AUTH_CONFIG_PATH, JSON.stringify(config2, null, 2), {
     mode: 384
   });
 }
@@ -525509,7 +525997,7 @@ function getProxyUrl() {
 }
 var DEFAULT_PROXY_URL = "https://8gi-model-proxy.fly.dev", AUTH_CONFIG_PATH;
 var init_proxy_provider = __esm(() => {
-  AUTH_CONFIG_PATH = path50.join(os32.homedir(), ".8gent", "auth-proxy.json");
+  AUTH_CONFIG_PATH = path52.join(os34.homedir(), ".8gent", "auth-proxy.json");
 });
 
 // packages/auth/index.ts
@@ -525838,8 +526326,8 @@ __export(exports_cron, {
   CronManager: () => CronManager
 });
 import * as crypto12 from "crypto";
-import * as fs51 from "fs";
-import * as path51 from "path";
+import * as fs53 from "fs";
+import * as path53 from "path";
 function matchField(field, value, max2) {
   if (field === "*")
     return true;
@@ -525869,22 +526357,22 @@ class CronManager {
   jobs;
   constructor(dataPath) {
     const home = process.env.HOME || process.env.USERPROFILE || "~";
-    this.filePath = dataPath || path51.join(home, ".8gent", "cron.json");
+    this.filePath = dataPath || path53.join(home, ".8gent", "cron.json");
     this.jobs = this.load();
   }
   load() {
     try {
-      if (fs51.existsSync(this.filePath)) {
-        return JSON.parse(fs51.readFileSync(this.filePath, "utf-8"));
+      if (fs53.existsSync(this.filePath)) {
+        return JSON.parse(fs53.readFileSync(this.filePath, "utf-8"));
       }
     } catch {}
     return [];
   }
   save() {
-    const dir = path51.dirname(this.filePath);
-    if (!fs51.existsSync(dir))
-      fs51.mkdirSync(dir, { recursive: true });
-    fs51.writeFileSync(this.filePath, JSON.stringify(this.jobs, null, 2));
+    const dir = path53.dirname(this.filePath);
+    if (!fs53.existsSync(dir))
+      fs53.mkdirSync(dir, { recursive: true });
+    fs53.writeFileSync(this.filePath, JSON.stringify(this.jobs, null, 2));
   }
   add(job) {
     const entry = { ...job, id: crypto12.randomUUID().slice(0, 8) };
@@ -525945,8 +526433,8 @@ __export(exports_session_export, {
   saveSessionExport: () => saveSessionExport,
   exportSession: () => exportSession
 });
-import * as fs52 from "fs";
-import * as path52 from "path";
+import * as fs54 from "fs";
+import * as path54 from "path";
 function escapeHtml(str) {
   return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
@@ -526030,10 +526518,10 @@ ${messageHtml}
 }
 async function saveSessionExport(messages, metadata) {
   const html3 = await exportSession(messages, metadata);
-  const dir = path52.join(process.env.HOME || process.env.USERPROFILE || ".", ".8gent", "exports");
-  fs52.mkdirSync(dir, { recursive: true });
-  const filePath = path52.join(dir, `${metadata.sessionId}.html`);
-  fs52.writeFileSync(filePath, html3, "utf-8");
+  const dir = path54.join(process.env.HOME || process.env.USERPROFILE || ".", ".8gent", "exports");
+  fs54.mkdirSync(dir, { recursive: true });
+  const filePath = path54.join(dir, `${metadata.sessionId}.html`);
+  fs54.writeFileSync(filePath, html3, "utf-8");
   return filePath;
 }
 var init_session_export = () => {};
@@ -526043,8 +526531,8 @@ var exports_preferences_sync = {};
 __export(exports_preferences_sync, {
   PreferencesSyncManager: () => PreferencesSyncManager
 });
-import * as fs53 from "fs";
-import * as path53 from "path";
+import * as fs55 from "fs";
+import * as path55 from "path";
 
 class PreferencesSyncManager {
   workingDirectory;
@@ -526054,7 +526542,7 @@ class PreferencesSyncManager {
   _resolved = false;
   constructor(workingDirectory = process.cwd()) {
     this.workingDirectory = workingDirectory;
-    this.userConfigPath = path53.join(workingDirectory, ".8gent", "user.json");
+    this.userConfigPath = path55.join(workingDirectory, ".8gent", "user.json");
   }
   async resolveConvex() {
     if (this._resolved)
@@ -526129,18 +526617,18 @@ class PreferencesSyncManager {
   }
   loadLocalConfig() {
     try {
-      if (fs53.existsSync(this.userConfigPath)) {
-        return JSON.parse(fs53.readFileSync(this.userConfigPath, "utf-8"));
+      if (fs55.existsSync(this.userConfigPath)) {
+        return JSON.parse(fs55.readFileSync(this.userConfigPath, "utf-8"));
       }
     } catch {}
     return null;
   }
   saveLocalConfig(config2) {
-    const dir = path53.dirname(this.userConfigPath);
-    if (!fs53.existsSync(dir)) {
-      fs53.mkdirSync(dir, { recursive: true });
+    const dir = path55.dirname(this.userConfigPath);
+    if (!fs55.existsSync(dir)) {
+      fs55.mkdirSync(dir, { recursive: true });
     }
-    fs53.writeFileSync(this.userConfigPath, JSON.stringify(config2, null, 2));
+    fs55.writeFileSync(this.userConfigPath, JSON.stringify(config2, null, 2));
   }
 }
 var init_preferences_sync = () => {};
@@ -526219,10 +526707,10 @@ Output a flat list. Each item: [ERROR|WARNING|INFO] file:line - description
 If no issues, say "No issues found." No preamble.`;
 
 // bin/8gent.ts
-import * as fs54 from "fs";
-import * as path54 from "path";
+import * as fs56 from "fs";
+import * as path56 from "path";
 var __dirname = "/Users/jamesspalding/8gent-code/bin";
-var VERSION5 = "0.11.0";
+var VERSION5 = "0.11.12";
 var BANNER = `
 \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
 \u2551                                                           \u2551
@@ -526545,11 +527033,11 @@ async function initCommand(args) {
   console.log(BANNER);
   console.log(`Initializing 8gent Code...
 `);
-  const configPath = path54.join(process.cwd(), ".8gent");
-  const indexPath = path54.join(configPath, "index");
-  if (!fs54.existsSync(configPath)) {
-    fs54.mkdirSync(configPath, { recursive: true });
-    fs54.mkdirSync(indexPath, { recursive: true });
+  const configPath = path56.join(process.cwd(), ".8gent");
+  const indexPath = path56.join(configPath, "index");
+  if (!fs56.existsSync(configPath)) {
+    fs56.mkdirSync(configPath, { recursive: true });
+    fs56.mkdirSync(indexPath, { recursive: true });
     const config2 = {
       version: VERSION5,
       initialized: new Date().toISOString(),
@@ -526560,7 +527048,7 @@ async function initCommand(args) {
         ignorePatterns: ["**/node_modules/**", "**/dist/**"]
       }
     };
-    fs54.writeFileSync(path54.join(configPath, "config.json"), JSON.stringify(config2, null, 2));
+    fs56.writeFileSync(path56.join(configPath, "config.json"), JSON.stringify(config2, null, 2));
     console.log("\u2705 Created .8gent directory");
     console.log("\u2705 Created config.json");
     console.log(`
@@ -526581,7 +527069,7 @@ async function outlineCommand(args) {
   const start = performance.now();
   const outline = parseTypeScriptFile2(filePath);
   const time3 = performance.now() - start;
-  const fileSize = fs54.statSync(filePath).size;
+  const fileSize = fs56.statSync(filePath).size;
   const fullTokens = Math.ceil(fileSize / 4);
   const outlineJson = JSON.stringify(outline.symbols);
   const outlineTokens = Math.ceil(outlineJson.length / 4);
@@ -526607,7 +527095,7 @@ async function outlineCommand(args) {
     }, null, 2));
   } else {
     console.log(`
-\uD83D\uDCC4 ${path54.basename(filePath)} (${outline.language})`);
+\uD83D\uDCC4 ${path56.basename(filePath)} (${outline.language})`);
     console.log(`   ${outline.symbols.length} symbols \u2022 ${time3.toFixed(1)}ms \u2022 ${percent}% token savings
 `);
     for (const symbol21 of outline.symbols) {
@@ -526648,14 +527136,14 @@ Available symbols:`);
     process.exit(1);
   }
   const source = getSymbolSource2(filePath, symbol21.startLine, symbol21.endLine, contextLines);
-  const fileSize = fs54.statSync(filePath).size;
+  const fileSize = fs56.statSync(filePath).size;
   const fullTokens = Math.ceil(fileSize / 4);
   const symbolTokens = Math.ceil(source.length / 4);
   const saved = fullTokens - symbolTokens;
   const percent = (saved / fullTokens * 100).toFixed(1);
   console.log(`
 ${getSymbolIcon(symbol21.kind)} ${symbol21.name} (${symbol21.kind})`);
-  console.log(`   Lines ${symbol21.startLine}-${symbol21.endLine} in ${path54.basename(filePath)}`);
+  console.log(`   Lines ${symbol21.startLine}-${symbol21.endLine} in ${path56.basename(filePath)}`);
   if (symbol21.signature) {
     console.log(`   ${symbol21.signature}`);
   }
@@ -526711,27 +527199,27 @@ async function searchCommand(args) {
   } else {
     for (const { symbol: symbol21, file: file2 } of matches) {
       const icon = getSymbolIcon(symbol21.kind);
-      console.log(`   ${icon} ${symbol21.name.padEnd(30)} ${symbol21.kind.padEnd(10)} ${path54.relative(process.cwd(), file2)}`);
+      console.log(`   ${icon} ${symbol21.name.padEnd(30)} ${symbol21.kind.padEnd(10)} ${path56.relative(process.cwd(), file2)}`);
     }
     console.log(`
    Found ${matches.length} match${matches.length === 1 ? "" : "es"}`);
   }
 }
 async function benchmarkCommand(args) {
-  const benchmarkPath = path54.join(__dirname, "../scripts/benchmark.ts");
+  const benchmarkPath = path56.join(__dirname, "../scripts/benchmark.ts");
   const { spawn: spawn14 } = await import("child_process");
   const proc = spawn14("bun", ["run", benchmarkPath, ...args], {
     stdio: "inherit",
-    cwd: path54.join(__dirname, "..")
+    cwd: path56.join(__dirname, "..")
   });
   proc.on("exit", (code2) => process.exit(code2 || 0));
 }
 async function demoCommand(args) {
-  const demoPath = path54.join(__dirname, "../scripts/demo-savings.ts");
+  const demoPath = path56.join(__dirname, "../scripts/demo-savings.ts");
   const { spawn: spawn14 } = await import("child_process");
   const proc = spawn14("bun", ["run", demoPath, ...args], {
     stdio: "inherit",
-    cwd: path54.join(__dirname, "..")
+    cwd: path56.join(__dirname, "..")
   });
   proc.on("exit", (code2) => process.exit(code2 || 0));
 }
@@ -526741,8 +527229,8 @@ async function spawnPet(sessionId) {
   if (platform4 !== "darwin") {
     console.log("\x1B[36m[pet] Lil Eight terminal mode (cross-platform)\x1B[0m");
     try {
-      const petPath = path54.join(__dirname, "../packages/pet/terminal-pet.ts");
-      if (fs54.existsSync(petPath)) {
+      const petPath = path56.join(__dirname, "../packages/pet/terminal-pet.ts");
+      if (fs56.existsSync(petPath)) {
         const { TerminalPet } = await import(petPath);
         const pet = new TerminalPet({ label: sessionId || "eight" });
         const rows = process.stdout.rows || 24;
@@ -526763,12 +527251,12 @@ async function spawnPet(sessionId) {
     } catch (e3) {}
     try {
       const home = process.env.HOME || process.env.USERPROFILE || "~";
-      const meshDir = path54.join(home, ".8gent", "mesh");
-      fs54.mkdirSync(meshDir, { recursive: true });
-      const registryPath = path54.join(meshDir, "registry.json");
+      const meshDir = path56.join(home, ".8gent", "mesh");
+      fs56.mkdirSync(meshDir, { recursive: true });
+      const registryPath = path56.join(meshDir, "registry.json");
       let registry2 = {};
       try {
-        registry2 = JSON.parse(fs54.readFileSync(registryPath, "utf-8"));
+        registry2 = JSON.parse(fs56.readFileSync(registryPath, "utf-8"));
       } catch {}
       const agentId = sessionId || `eight-tui-${process.pid}`;
       registry2[agentId] = {
@@ -526782,7 +527270,7 @@ async function spawnPet(sessionId) {
         lastHeartbeat: Date.now(),
         channel: "terminal"
       };
-      fs54.writeFileSync(registryPath, JSON.stringify(registry2, null, 2));
+      fs56.writeFileSync(registryPath, JSON.stringify(registry2, null, 2));
     } catch {}
     return;
   }
@@ -526790,8 +527278,8 @@ async function spawnPet(sessionId) {
     const { generateCompanion: generateCompanion2 } = await Promise.resolve().then(() => (init_companion(), exports_companion));
     const companion = generateCompanion2(sessionId || `session-${Date.now()}`);
     const home = process.env.HOME || "~";
-    fs54.mkdirSync(path54.join(home, ".8gent"), { recursive: true });
-    fs54.writeFileSync(path54.join(home, ".8gent", "active-companion.json"), JSON.stringify({
+    fs56.mkdirSync(path56.join(home, ".8gent"), { recursive: true });
+    fs56.writeFileSync(path56.join(home, ".8gent", "active-companion.json"), JSON.stringify({
       fullName: companion.fullName,
       species: companion.species,
       element: companion.element,
@@ -526803,11 +527291,11 @@ async function spawnPet(sessionId) {
       stats: companion.stats
     }, null, 2));
   } catch {}
-  const lilEightScript = path54.join(__dirname, "lil-eight.sh");
+  const lilEightScript = path56.join(__dirname, "lil-eight.sh");
   try {
     execSync4("pkill -f LilEight 2>/dev/null", { stdio: "pipe" });
   } catch {}
-  if (fs54.existsSync(lilEightScript)) {
+  if (fs56.existsSync(lilEightScript)) {
     const pet = spawnProc("bash", [lilEightScript, "start"], {
       detached: true,
       stdio: "ignore"
@@ -526815,8 +527303,8 @@ async function spawnPet(sessionId) {
     pet.unref();
     console.log("\x1B[36m[pet] Lil Eight spawned on Dock\x1B[0m");
   } else {
-    const buildScript = path54.join(__dirname, "../apps/lil-eight/build.sh");
-    if (fs54.existsSync(buildScript)) {
+    const buildScript = path56.join(__dirname, "../apps/lil-eight/build.sh");
+    if (fs56.existsSync(buildScript)) {
       console.log("\x1B[36m[pet] Building Lil Eight...\x1B[0m");
       try {
         execSync4(`bash "${buildScript}"`, { stdio: "pipe" });
@@ -526832,13 +527320,13 @@ async function spawnPet(sessionId) {
     }
   }
   try {
-    const meshDir = path54.join(process.env.HOME || "~", ".8gent", "mesh");
-    const registryPath = path54.join(meshDir, "registry.json");
-    fs54.mkdirSync(meshDir, { recursive: true });
+    const meshDir = path56.join(process.env.HOME || "~", ".8gent", "mesh");
+    const registryPath = path56.join(meshDir, "registry.json");
+    fs56.mkdirSync(meshDir, { recursive: true });
     const agentId = sessionId || `eight-tui-${process.pid}`;
     let registry2 = {};
     try {
-      registry2 = JSON.parse(fs54.readFileSync(registryPath, "utf-8"));
+      registry2 = JSON.parse(fs56.readFileSync(registryPath, "utf-8"));
     } catch {}
     registry2[agentId] = {
       id: agentId,
@@ -526851,12 +527339,12 @@ async function spawnPet(sessionId) {
       lastHeartbeat: Date.now(),
       channel: "terminal"
     };
-    fs54.writeFileSync(registryPath, JSON.stringify(registry2, null, 2));
+    fs56.writeFileSync(registryPath, JSON.stringify(registry2, null, 2));
     const cleanup = () => {
       try {
-        const reg = JSON.parse(fs54.readFileSync(registryPath, "utf-8"));
+        const reg = JSON.parse(fs56.readFileSync(registryPath, "utf-8"));
         delete reg[agentId];
-        fs54.writeFileSync(registryPath, JSON.stringify(reg, null, 2));
+        fs56.writeFileSync(registryPath, JSON.stringify(reg, null, 2));
       } catch {}
     };
     process.on("exit", cleanup);
@@ -526880,10 +527368,10 @@ async function tuiCommand(args) {
   console.log(`Launching TUI...
 `);
   const { spawn: spawn14 } = await import("child_process");
-  const tuiPath = path54.join(__dirname, "../apps/tui/src/index.tsx");
+  const tuiPath = path56.join(__dirname, "../apps/tui/src/index.tsx");
   const proc = spawn14("bun", ["run", tuiPath, ...filteredArgs], {
     stdio: "inherit",
-    cwd: path54.join(__dirname, "..")
+    cwd: path56.join(__dirname, "..")
   });
   proc.on("exit", (code2) => process.exit(code2 || 0));
 }
@@ -526901,8 +527389,8 @@ async function airdropCommand(args) {
   }
   const target = args.join(" ");
   const { execSync: execSync4 } = await import("child_process");
-  if (fs54.existsSync(target) || fs54.existsSync(path54.resolve(target))) {
-    const resolved = path54.resolve(target);
+  if (fs56.existsSync(target) || fs56.existsSync(path56.resolve(target))) {
+    const resolved = path56.resolve(target);
     console.log(`AirDropping: ${resolved}`);
     const script = `
       tell application "Finder"
@@ -526932,7 +527420,7 @@ async function airdropCommand(args) {
       }
     `;
     const tmpSwift = "/tmp/eight-airdrop.swift";
-    fs54.writeFileSync(tmpSwift, swiftHelper);
+    fs56.writeFileSync(tmpSwift, swiftHelper);
     try {
       execSync4(`swiftc -o /tmp/eight-airdrop -framework Cocoa "${tmpSwift}" && /tmp/eight-airdrop`, {
         stdio: "inherit",
@@ -526943,7 +527431,7 @@ async function airdropCommand(args) {
     }
   } else {
     const tmpFile = `/tmp/eight-note-${Date.now()}.txt`;
-    fs54.writeFileSync(tmpFile, target);
+    fs56.writeFileSync(tmpFile, target);
     console.log(`AirDropping note: "${target.slice(0, 50)}..."`);
     await airdropCommand([tmpFile]);
   }
@@ -526951,10 +527439,10 @@ async function airdropCommand(args) {
 async function petCommand(args) {
   const subCmd = args[0] || "start";
   const { execSync: execSync4 } = await import("child_process");
-  const lilEightScript = path54.join(__dirname, "lil-eight.sh");
-  if (!fs54.existsSync(lilEightScript)) {
+  const lilEightScript = path56.join(__dirname, "lil-eight.sh");
+  if (!fs56.existsSync(lilEightScript)) {
     console.log("Building Lil Eight first...");
-    const buildScript = path54.join(__dirname, "../apps/lil-eight/build.sh");
+    const buildScript = path56.join(__dirname, "../apps/lil-eight/build.sh");
     execSync4(`bash "${buildScript}"`, { stdio: "inherit" });
   }
   switch (subCmd) {
@@ -526978,14 +527466,14 @@ async function petCommand(args) {
       setTimeout(() => spawnPet(), 1000);
       break;
     case "build":
-      execSync4(`bash "${path54.join(__dirname, "../apps/lil-eight/build.sh")}"`, {
+      execSync4(`bash "${path56.join(__dirname, "../apps/lil-eight/build.sh")}"`, {
         stdio: "inherit"
       });
       break;
     case "log":
     case "logs": {
       const { spawn: sp } = await import("child_process");
-      const logPath = path54.join(process.env.HOME || "~", ".8gent", "lil-eight.log");
+      const logPath = path56.join(process.env.HOME || "~", ".8gent", "lil-eight.log");
       sp("tail", ["-f", logPath], { stdio: "inherit" });
       break;
     }
@@ -526993,9 +527481,9 @@ async function petCommand(args) {
       try {
         execSync4("pgrep -f LilEight", { stdio: "pipe" });
         console.log("Lil Eight is running");
-        const logP = path54.join(process.env.HOME || "~", ".8gent", "lil-eight.log");
-        if (fs54.existsSync(logP)) {
-          const lines = fs54.readFileSync(logP, "utf-8").trim().split(`
+        const logP = path56.join(process.env.HOME || "~", ".8gent", "lil-eight.log");
+        if (fs56.existsSync(logP)) {
+          const lines = fs56.readFileSync(logP, "utf-8").trim().split(`
 `).slice(-3);
           lines.forEach((l2) => console.log(`  ${l2}`));
         }
@@ -527495,10 +527983,10 @@ async function sessionCommand(args) {
         process.exit(1);
       }
       const { spawn: spawn14 } = await import("child_process");
-      const tuiPath = path54.join(__dirname, "../apps/tui/src/index.tsx");
+      const tuiPath = path56.join(__dirname, "../apps/tui/src/index.tsx");
       const proc = spawn14("bun", ["run", tuiPath, "--resume", nameOrId], {
         stdio: "inherit",
-        cwd: path54.join(__dirname, "..")
+        cwd: path56.join(__dirname, "..")
       });
       proc.on("exit", (code2) => process.exit(code2 || 0));
       break;
@@ -527809,9 +528297,9 @@ async function statusCommand(args) {
     runtime: "bun"
   };
   try {
-    const configPath = path54.join(cwd, ".8gent", "config.json");
-    if (fs54.existsSync(configPath)) {
-      status.config = JSON.parse(fs54.readFileSync(configPath, "utf-8"));
+    const configPath = path56.join(cwd, ".8gent", "config.json");
+    if (fs56.existsSync(configPath)) {
+      status.config = JSON.parse(fs56.readFileSync(configPath, "utf-8"));
     }
   } catch {}
   try {
@@ -527923,7 +528411,7 @@ async function reviewCommand(args) {
   let diff;
   try {
     if (diffFile) {
-      diff = fs54.readFileSync(diffFile, "utf-8");
+      diff = fs56.readFileSync(diffFile, "utf-8");
     } else if (prNumber) {
       diff = execSync4(`gh pr diff ${prNumber}`, { encoding: "utf-8" });
     } else {
@@ -527986,12 +528474,12 @@ async function doctorCommand() {
       issues++;
     }
   }
-  const dbPath = path54.join(process.env.HOME || "", ".8gent", "memory.db");
-  console.log(fs54.existsSync(dbPath) ? green(`Memory DB (${(fs54.statSync(dbPath).size / 1024).toFixed(0)} KB)`) : dim("  No memory DB yet"));
-  const cfgPath = path54.join(process.env.HOME || "", ".8gent", "config.json");
-  if (fs54.existsSync(cfgPath)) {
+  const dbPath = path56.join(process.env.HOME || "", ".8gent", "memory.db");
+  console.log(fs56.existsSync(dbPath) ? green(`Memory DB (${(fs56.statSync(dbPath).size / 1024).toFixed(0)} KB)`) : dim("  No memory DB yet"));
+  const cfgPath = path56.join(process.env.HOME || "", ".8gent", "config.json");
+  if (fs56.existsSync(cfgPath)) {
     try {
-      JSON.parse(fs54.readFileSync(cfgPath, "utf-8"));
+      JSON.parse(fs56.readFileSync(cfgPath, "utf-8"));
       console.log(green("Config valid"));
     } catch {
       console.log(red("Config invalid JSON"));
@@ -528008,10 +528496,10 @@ async function doctorCommand() {
   } catch {
     console.log(dim("  NemoClaw skip"));
   }
-  const mcpPath = path54.join(process.env.HOME || "", ".8gent", "mcp.json");
-  if (fs54.existsSync(mcpPath)) {
+  const mcpPath = path56.join(process.env.HOME || "", ".8gent", "mcp.json");
+  if (fs56.existsSync(mcpPath)) {
     try {
-      const m2 = JSON.parse(fs54.readFileSync(mcpPath, "utf-8"));
+      const m2 = JSON.parse(fs56.readFileSync(mcpPath, "utf-8"));
       console.log(green(`MCP: ${Object.keys(m2.servers || m2.mcpServers || {}).length} servers`));
     } catch {
       console.log(red("MCP config invalid"));