aiden-runtime 3.19.4 → 3.19.6

package/dist-bundle/index.js

@@ -26650,7 +26650,7 @@ var require_websocket_server = __commonJS({
 var VERSION;
 var init_version = __esm({
   "core/version.ts"() {
-    VERSION = "3.19.4";
+    VERSION = "3.19.6";
   }
 });
 
@@ -99142,6 +99142,8 @@ var init_skillLoader = __esm({
           import_path15.default.join(process.cwd(), "workspace", "skills"),
           import_path15.default.join(process.cwd(), "workspace", "skills", "learned"),
           import_path15.default.join(process.cwd(), "workspace", "skills", "approved"),
+          // Workspace-level installed skills (written by skillRegistry.ts)
+          import_path15.default.join(process.cwd(), "workspace", "skills", "installed"),
           // A2/A3 approved drafts
           import_path15.default.join(process.cwd(), "skills", "learned", "approved"),
           // A4 library-installed skills
@@ -99759,6 +99761,7 @@ var init_modelRegistry = __esm({
 var router_exports = {};
 __export(router_exports, {
   assessComplexity: () => assessComplexity,
+  diagnoseProviderPool: () => diagnoseProviderPool,
   enterDegradedMode: () => enterDegradedMode,
   exitDegradedMode: () => exitDegradedMode,
   getLocalModels: () => getLocalModels,
@@ -99873,6 +99876,51 @@ function autoResetExpiredLimits() {
   if (changed) saveConfig(config2);
   return changed;
 }
+function diagnoseProviderPool() {
+  const config2 = loadConfig();
+  const allApis = mergeCustomProviders(config2.providers.apis);
+  const enabled = allApis.filter((a) => a.enabled);
+  const disabledCount = allApis.length - enabled.length;
+  let noKey = 0, rateLimited = 0;
+  for (const a of enabled) {
+    if (a.rateLimited) {
+      rateLimited++;
+      continue;
+    }
+    if (a.provider === "custom") continue;
+    const k = a.key.startsWith("env:") ? process.env[a.key.replace("env:", "")] || "" : a.key;
+    if (k.length === 0) noKey++;
+  }
+  const active = enabled.length - noKey - rateLimited;
+  if (active > 0)
+    return { state: "ok", noKeyCount: noKey, rateLimitedCount: rateLimited, disabledCount, enabledCount: enabled.length, message: "" };
+  if (noKey > 0 && rateLimited === 0)
+    return {
+      state: "unconfigured",
+      noKeyCount: noKey,
+      rateLimitedCount: 0,
+      disabledCount,
+      enabledCount: enabled.length,
+      message: "No API keys configured - add keys in Settings > API Keys or set env vars"
+    };
+  if (rateLimited > 0 && noKey === 0)
+    return {
+      state: "rate-limited",
+      noKeyCount: 0,
+      rateLimitedCount: rateLimited,
+      disabledCount,
+      enabledCount: enabled.length,
+      message: `All ${rateLimited} cloud provider(s) rate-limited - retrying automatically`
+    };
+  return {
+    state: "mixed",
+    noKeyCount: noKey,
+    rateLimitedCount: rateLimited,
+    disabledCount,
+    enabledCount: enabled.length,
+    message: `${noKey} provider(s) have no key, ${rateLimited} rate-limited`
+  };
+}
 function getNextAvailableAPI() {
   autoResetExpiredLimits();
   const config2 = loadConfig();
@@ -99883,7 +99931,11 @@ function getNextAvailableAPI() {
     const resolvedKey = api.key.startsWith("env:") ? process.env[api.key.replace("env:", "")] || "" : api.key;
     return resolvedKey.length > 0;
   });
-  if (!available.length) return null;
+  if (!available.length) {
+    const diag = diagnoseProviderPool();
+    if (diag.message) console.log(`[Router] ${diag.message}`);
+    return null;
+  }
   const primary = config2.primaryProvider;
   const scored = available.map((api) => {
     const avgMs = responseTimesMs.get(api.name) ?? 2e3;
@@ -100036,7 +100088,8 @@ function getModelForTask(task, message) {
       return resolveKey(chosen);
     }
     const model = getOllamaModelForTask(task === "planner" ? "planner" : "responder");
-    console.log(`[Router] ${task}: all cloud providers rate-limited - using Ollama ${model}`);
+    const diag = diagnoseProviderPool();
+    console.log(`[Router] ${task}: ${diag.message || "all cloud providers unavailable"} - using Ollama ${model}`);
     return { apiKey: "", model, providerName: "ollama", apiName: "ollama" };
   }
   if (task === "executor") {
@@ -100045,7 +100098,8 @@ function getModelForTask(task, message) {
       if (api) return resolveKey(api);
     }
     const model = getOllamaModelForTask("executor");
-    console.log(`[Router] Executor: all cloud providers unavailable - falling back to Ollama ${model}`);
+    const diag = diagnoseProviderPool();
+    console.log(`[Router] Executor: ${diag.message || "all cloud providers unavailable"} - falling back to Ollama ${model}`);
     return { apiKey: "", model, providerName: "ollama", apiName: "ollama" };
   }
   if (available.length > 0) return resolveKey(available[0]);
@@ -100069,7 +100123,8 @@ function getSmartProvider() {
   }
   if (config2.routing?.fallbackToOllama !== false) {
     const model2 = getOllamaModelForTask("responder");
-    console.log(`[Router] All APIs unavailable \u2014 falling back to Ollama ${model2}`);
+    const diag = diagnoseProviderPool();
+    console.log(`[Router] ${diag.message || "All APIs unavailable"} - falling back to Ollama ${model2}`);
     return { provider: ollamaProvider, model: model2, userName, apiName: "ollama" };
   }
   const model = getOllamaModelForTask("responder");
@@ -100111,7 +100166,7 @@ function enterDegradedMode(reason) {
   }
   return {
     mode: "degraded",
-    message: `I'm temporarily running in limited mode \u2014 my AI providers are at capacity. I can still:
+    message: `I'm temporarily running in limited mode \u2014 ${diagnoseProviderPool().state === "unconfigured" ? "no API keys are configured" : "my AI providers are at capacity"}. I can still:
 \u2022 Search your files and memory
 \u2022 Run scheduled tasks
 \u2022 Execute shell commands and scripts
@@ -365359,7 +365414,7 @@ ${summaryInput}`,
   if (!parsed) {
     console.warn("[Planner] All LLM attempts failed \u2014 respond fallback (going through guard)");
     parsed = {
-      plan: [{ step: 1, tool: "respond", input: { message: buildDiagnostic({ tool: "planner", error: "All LLM attempts failed", retries: 3, suggestion: "Provider chain may be rate-limited. Try again in 1\u20132 minutes or rephrase your request." }) }, description: "Fallback response" }],
+      plan: [{ step: 1, tool: "respond", input: { message: buildDiagnostic({ tool: "planner", error: "All LLM attempts failed", retries: 3, suggestion: diagnoseProviderPool().state === "unconfigured" ? "No API keys configured. Add keys in Settings > API Keys, or start Ollama for local inference." : "Provider chain is rate-limited. Try again in 1-2 minutes or rephrase your request." }) }, description: "Fallback response" }],
       requires_execution: true,
       goal: message
     };
@@ -365491,7 +365546,7 @@ Fix these issues and output a corrected JSON plan.`
           tool: "planner",
           error: "Could not generate tool plan for action intent",
           retries: 1,
-          suggestion: "Provider chain may be rate-limited. Try again in 1\u20132 minutes or use a more specific instruction."
+          suggestion: diagnoseProviderPool().state === "unconfigured" ? "No API keys configured. Add keys in Settings > API Keys, or start Ollama for local inference." : "Provider chain is rate-limited. Try again in 1-2 minutes or use a more specific instruction."
         });
       }
       if (guardMatch) {
@@ -366599,7 +366654,8 @@ Respond naturally based on these real results only. Show the actual output, not
       parts.push(
         `Failed: ${failures.map((r) => `${r.tool} \u2014 ${r.error || "unknown error"}`).join("; ")}.`
       );
-      parts.push("(All language providers are currently unavailable \u2014 full response cannot be generated.)");
+      const poolDiag = diagnoseProviderPool();
+      parts.push(`(${poolDiag.state === "unconfigured" ? "No API keys configured - add keys in Settings > API Keys" : "All language providers are currently unavailable"} - full response cannot be generated.)`);
       onToken(parts.join(" "));
       return;
     }
@@ -390371,6 +390427,368 @@ var init_hybridSearch = __esm({
   }
 });
 
+// core/memoryIds.ts
+function _ensureDir() {
+  fs45.mkdirSync(MEM_DIR, { recursive: true });
+}
+function _readSeq() {
+  try {
+    if (!fs45.existsSync(SEQUENCE_FILE)) return 0;
+    const d = JSON.parse(fs45.readFileSync(SEQUENCE_FILE, "utf-8"));
+    return typeof d.next === "number" ? d.next : 0;
+  } catch {
+    return 0;
+  }
+}
+function _writeSeq(n) {
+  _ensureDir();
+  fs45.writeFileSync(SEQUENCE_FILE, JSON.stringify({ next: n }), "utf-8");
+}
+function nextId() {
+  const n = _readSeq();
+  _writeSeq(n + 1);
+  return `mem_${String(n + 1).padStart(6, "0")}`;
+}
+function appendRecord(record2) {
+  _ensureDir();
+  fs45.appendFileSync(RECORDS_FILE, JSON.stringify(record2) + "\n", "utf-8");
+}
+function loadAllRecords() {
+  try {
+    if (!fs45.existsSync(RECORDS_FILE)) return [];
+    return fs45.readFileSync(RECORDS_FILE, "utf-8").split("\n").filter((l2) => l2.trim()).map((l2) => {
+      try {
+        return JSON.parse(l2);
+      } catch {
+        return null;
+      }
+    }).filter((r) => r !== null);
+  } catch {
+    return [];
+  }
+}
+function loadRecordById(id) {
+  const all3 = loadAllRecords();
+  return all3.find((r) => r.id === id) ?? null;
+}
+function removeRecords(predicate) {
+  const all3 = loadAllRecords();
+  const kept = all3.filter((r) => !predicate(r));
+  const removed = all3.length - kept.length;
+  if (removed > 0) {
+    _ensureDir();
+    fs45.writeFileSync(
+      RECORDS_FILE,
+      kept.map((r) => JSON.stringify(r)).join("\n") + (kept.length ? "\n" : ""),
+      "utf-8"
+    );
+  }
+  return removed;
+}
+function assignId(partial2) {
+  const record2 = {
+    id: partial2.id ?? nextId(),
+    timestamp: partial2.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+    type: partial2.type ?? "observation",
+    content: partial2.content ?? "",
+    summary: partial2.summary ?? _autoSummary(partial2.content ?? ""),
+    sessionId: partial2.sessionId,
+    tags: partial2.tags,
+    entityRefs: partial2.entityRefs
+  };
+  appendRecord(record2);
+  return record2;
+}
+function _autoSummary(content) {
+  const first = content.split("\n").find((l2) => l2.trim()) ?? content;
+  return first.slice(0, 100).trim();
+}
+function runMigrationIfNeeded() {
+  if (fs45.existsSync(RECORDS_FILE)) return 0;
+  _ensureDir();
+  const records = [];
+  try {
+    const raw = fs45.readFileSync(path47.join(MEM_DIR, "memory.json"), "utf-8");
+    const parsed = JSON.parse(raw);
+    const items = Array.isArray(parsed) ? parsed : parsed.value ?? [];
+    for (const item of items) {
+      const v = item.value ?? {};
+      const content = [
+        v.goal ? `Goal: ${v.goal}` : "",
+        v.result ? `Result: ${String(v.result).slice(0, 800)}` : "",
+        v.role ? `Role: ${v.role}` : ""
+      ].filter(Boolean).join("\n");
+      if (!content) continue;
+      records.push({
+        timestamp: item.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        type: item.tags?.includes("task") ? "interaction" : "observation",
+        content,
+        summary: _autoSummary(v.goal ?? v.result ?? content),
+        tags: item.tags ?? []
+      });
+    }
+  } catch {
+  }
+  try {
+    const raw = fs45.readFileSync(
+      path47.join(process.cwd(), "workspace", "conversation-memory.json"),
+      "utf-8"
+    );
+    const parsed = JSON.parse(raw);
+    const msgs = parsed.messages ?? [];
+    for (const msg of msgs) {
+      if (msg.role !== "assistant") continue;
+      const content = String(msg.content ?? "").trim();
+      if (content.length < 20) continue;
+      records.push({
+        timestamp: msg.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+        type: "interaction",
+        content: content.slice(0, 1e3),
+        summary: _autoSummary(content),
+        sessionId: msg.sessionId,
+        tags: ["conversation"]
+      });
+    }
+  } catch {
+  }
+  try {
+    const raw = fs45.readFileSync(path47.join(MEM_DIR, "MEMORY_INDEX.md"), "utf-8");
+    const lines = raw.split("\n").filter((l2) => l2.startsWith("- "));
+    for (const line of lines) {
+      const cleaned = line.replace(/^-\s*/, "").trim();
+      if (cleaned.length < 10) continue;
+      records.push({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "fact",
+        content: cleaned,
+        summary: cleaned.slice(0, 100),
+        tags: ["index"]
+      });
+    }
+  } catch {
+  }
+  records.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+  let count = 0;
+  for (const rec of records) {
+    const id = nextId();
+    const record2 = { id, ...rec };
+    appendRecord(record2);
+    count++;
+  }
+  return count;
+}
+var fs45, path47, MEM_DIR, SEQUENCE_FILE, RECORDS_FILE;
+var init_memoryIds = __esm({
+  "core/memoryIds.ts"() {
+    fs45 = __toESM(require("fs"));
+    path47 = __toESM(require("path"));
+    MEM_DIR = path47.join(process.cwd(), "workspace", "memory");
+    SEQUENCE_FILE = path47.join(MEM_DIR, "sequence.json");
+    RECORDS_FILE = path47.join(MEM_DIR, "records.jsonl");
+  }
+});
+
+// core/slashAsTool.ts
+var slashAsTool_exports = {};
+__export(slashAsTool_exports, {
+  SLASH_MIRROR_TOOL_NAMES: () => SLASH_MIRROR_TOOL_NAMES,
+  registerSlashMirrorTools: () => registerSlashMirrorTools,
+  toolMemoryForget: () => toolMemoryForget,
+  toolMemoryStore: () => toolMemoryStore
+});
+function loadLessonsText() {
+  try {
+    if (import_fs40.default.existsSync(LESSONS_PATH2)) return import_fs40.default.readFileSync(LESSONS_PATH2, "utf-8").trim();
+  } catch {
+  }
+  return "";
+}
+async function toolStatus(_2) {
+  const uptimeSec = Math.floor(process.uptime());
+  const ramMB = Math.round(process.memoryUsage().heapUsed / 1024 / 1024);
+  const sessions = conversationMemory.getSessions().length;
+  const lines = [
+    "SYSTEM STATUS",
+    `Uptime       ${Math.floor(uptimeSec / 60)}m ${uptimeSec % 60}s`,
+    `RAM          ${ramMB} MB`,
+    `Sessions     ${sessions}`,
+    `Platform     ${import_os4.default.platform()} ${import_os4.default.arch()}`,
+    `Node         ${process.version}`
+  ];
+  return { success: true, output: lines.join("\n") };
+}
+async function toolAnalytics(_2) {
+  const stats = learningMemory.getStats();
+  const lines = [
+    "LEARNING ANALYTICS",
+    `Total tasks    ${stats.total}`,
+    `Success rate   ${stats.successRate}%`,
+    `Avg duration   ${stats.avgDuration}ms`
+  ];
+  return { success: true, output: lines.join("\n") };
+}
+async function toolSpend(_2) {
+  try {
+    const summary = costTracker.getDailySummary();
+    const byProvider = Object.entries(summary.byProvider || {}).map(([p, c]) => `  ${p}: $${c.toFixed(4)}`).join("\n");
+    const lines = [
+      `SPEND \u2014 ${summary.date}`,
+      `Total   $${summary.totalUSD.toFixed(4)}`,
+      `User    $${summary.userUSD.toFixed(4)}`,
+      `System  $${summary.systemUSD.toFixed(4)}`,
+      byProvider ? `By provider:
+${byProvider}` : ""
+    ].filter(Boolean);
+    return { success: true, output: lines.join("\n") };
+  } catch {
+    return { success: true, output: "Spend data unavailable." };
+  }
+}
+async function toolMemoryShow(_2) {
+  const facts = conversationMemory.getFacts();
+  const history2 = conversationMemory.getRecentHistory();
+  const lines = [
+    "MEMORY FACTS",
+    facts.lastFilesCreated.length ? `Files created : ${facts.lastFilesCreated.join(", ")}` : "",
+    facts.lastSearchQueries.length ? `Last searches : ${facts.lastSearchQueries.join(", ")}` : "",
+    facts.lastToolsUsed.length ? `Last tools    : ${facts.lastToolsUsed.join(", ")}` : "",
+    facts.mentionedEntities.length ? `Topics        : ${facts.mentionedEntities.slice(-10).join(", ")}` : "",
+    "",
+    `Recent exchanges: ${history2.length}`,
+    ...history2.slice(-3).map(
+      (e) => e.userMessage ? `  User: ${e.userMessage.slice(0, 80)}` : ""
+    ).filter(Boolean)
+  ].filter((l2) => l2 !== void 0);
+  return { success: true, output: lines.join("\n") };
+}
+async function toolLessons(_2) {
+  const lessons = loadLessonsText();
+  if (!lessons) return { success: true, output: "No lessons recorded yet." };
+  return { success: true, output: `LESSONS (permanent failure rules):
+${lessons}` };
+}
+async function toolSkillsList(_2) {
+  const skills = skillLoader.loadAll();
+  if (skills.length === 0) return { success: true, output: "No skills loaded." };
+  const lines = [
+    `SKILLS (${skills.length} loaded)`,
+    ...skills.map((s) => `  ${s.name.padEnd(20)} ${s.description || ""}`)
+  ];
+  return { success: true, output: lines.join("\n") };
+}
+async function toolToolsList(_2) {
+  const { TOOLS: TOOLS3 } = await Promise.resolve().then(() => (init_toolRegistry(), toolRegistry_exports));
+  const names = Object.keys(TOOLS3).sort();
+  return { success: true, output: `TOOLS (${names.length}):
+${names.join(", ")}` };
+}
+async function toolWhoami(_2) {
+  const cfg = loadConfig();
+  const userName = cfg.userName || process.env.USERNAME || import_os4.default.userInfo().username || "User";
+  const homeDir = import_os4.default.homedir();
+  const lines = [
+    "USER PROFILE",
+    `Name         ${userName}`,
+    `Home         ${homeDir}`,
+    `Platform     ${import_os4.default.platform()}`
+  ];
+  return { success: true, output: lines.join("\n") };
+}
+async function toolChannelsStatus(_2) {
+  try {
+    const cfg = loadConfig();
+    const apis = cfg?.providers?.apis || [];
+    const lines = [
+      "PROVIDER CHANNELS",
+      ...apis.map((api) => {
+        const key2 = String(api.key || "");
+        const hasKey = key2.startsWith("env:") ? !!(process.env[key2.replace("env:", "")] || "").trim() : key2.trim().length > 0;
+        const status = !api.enabled ? "disabled" : api.rateLimited ? "rate-limited" : hasKey ? "active" : "no key";
+        return `  ${(api.name || api.provider || "").padEnd(20)} ${api.model || ""}  [${status}]`;
+      })
+    ];
+    return { success: true, output: lines.join("\n") };
+  } catch {
+    return { success: true, output: "Provider status unavailable." };
+  }
+}
+async function toolMemoryStore(input) {
+  const fact = String(
+    input?.fact || input?.content || input?.text || input?.preference || input?.value || input?.memory || input?.note || input?.data || input?.information || input?.detail || input?.message || input?.entry || input?.record || (input && typeof input === "object" ? Object.values(input).find((v) => typeof v === "string" && v.trim().length > 0) : "") || ""
+  ).trim();
+  if (!fact) return { success: false, output: 'No fact provided. Pass { fact: "the thing to remember" }' };
+  const record2 = assignId({
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    type: input?.type ?? "fact",
+    content: fact,
+    summary: fact.slice(0, 100),
+    tags: Array.isArray(input?.tags) ? input.tags : []
+  });
+  return { success: true, output: `Stored as ${record2.id}: ${record2.summary}` };
+}
+async function toolMemoryForget(input) {
+  const keyword = String(
+    input?.fact || input?.keyword || input?.content || input?.text || input?.query || input?.topic || input?.subject || (input && typeof input === "object" ? Object.values(input).find((v) => typeof v === "string" && v.trim().length > 0) : "") || ""
+  ).trim().toLowerCase();
+  if (!keyword)
+    return { success: false, output: 'No keyword provided. Pass { fact: "thing to forget" }' };
+  const removed = removeRecords(
+    (r) => r.content.toLowerCase().includes(keyword) || r.summary.toLowerCase().includes(keyword)
+  );
+  if (removed === 0)
+    return { success: true, output: `No memory entries matched "${keyword}".` };
+  return { success: true, output: `Removed ${removed} memory entry(s) matching "${keyword}".` };
+}
+async function toolGoals(_2) {
+  const summary = getActiveGoalsSummary();
+  return { success: true, output: summary ? `ACTIVE GOALS:
+${summary}` : "No active goals." };
+}
+function registerSlashMirrorTools() {
+  const isDebug = (process.env.AIDEN_LOG_LEVEL || "info") === "debug";
+  for (const { name, description, fn } of MIRROR_TOOLS) {
+    registerExternalTool(name, fn, "slash-mirror");
+    if (isDebug) {
+      console.log("[SlashAsTool] Registered mirror tool: " + name + " \u2014 " + description);
+    }
+  }
+  if (!isDebug) {
+    console.log("[SlashAsTool] Registered " + MIRROR_TOOLS.length + " mirror tools (AIDEN_LOG_LEVEL=debug for detail)");
+  }
+}
+var import_fs40, import_path42, import_os4, LESSONS_PATH2, MIRROR_TOOLS, SLASH_MIRROR_TOOL_NAMES;
+var init_slashAsTool = __esm({
+  "core/slashAsTool.ts"() {
+    import_fs40 = __toESM(require("fs"));
+    import_path42 = __toESM(require("path"));
+    import_os4 = __toESM(require("os"));
+    init_toolRegistry();
+    init_memoryIds();
+    init_conversationMemory();
+    init_learningMemory();
+    init_skillLoader();
+    init_costTracker();
+    init_goalTracker();
+    init_providers();
+    LESSONS_PATH2 = import_path42.default.join(process.cwd(), "workspace", "LESSONS.md");
+    MIRROR_TOOLS = [
+      { name: "status", description: "Show system status: uptime, RAM, session count", fn: toolStatus },
+      { name: "analytics", description: "Show learning analytics: task count, success rate", fn: toolAnalytics },
+      { name: "spend", description: "Show today's token cost and spend by provider", fn: toolSpend },
+      { name: "memory_show", description: "Show conversation memory facts and recent history", fn: toolMemoryShow },
+      { name: "memory_store", description: 'Persist a fact or preference to permanent memory (records.jsonl) right now. Pass { fact: "..." }', fn: toolMemoryStore },
+      { name: "memory_forget", description: 'Remove a fact or preference from permanent memory (records.jsonl). Pass { fact: "thing to forget" }', fn: toolMemoryForget },
+      { name: "lessons", description: "Show permanent failure rules learned from past tasks", fn: toolLessons },
+      { name: "skills_list", description: "List all loaded skills with descriptions", fn: toolSkillsList },
+      { name: "tools_list", description: "List all registered tool names", fn: toolToolsList },
+      { name: "whoami", description: "Show current user profile: name, home dir, platform", fn: toolWhoami },
+      { name: "channels_status", description: "Show provider channel status: active, disabled, no-key", fn: toolChannelsStatus },
+      { name: "goals", description: "Show currently active goals", fn: toolGoals }
+    ];
+    SLASH_MIRROR_TOOL_NAMES = MIRROR_TOOLS.map((t) => t.name);
+  }
+});
+
 // core/clarifyBus.ts
 var clarifyBus_exports = {};
 __export(clarifyBus_exports, {
@@ -390500,15 +390918,15 @@ __export(cronManager_exports, {
 });
 function save() {
   try {
-    if (!fs45.existsSync(DATA_DIR)) fs45.mkdirSync(DATA_DIR, { recursive: true });
-    fs45.writeFileSync(DATA_FILE, JSON.stringify(Array.from(jobs.values()), null, 2), "utf8");
+    if (!fs47.existsSync(DATA_DIR)) fs47.mkdirSync(DATA_DIR, { recursive: true });
+    fs47.writeFileSync(DATA_FILE, JSON.stringify(Array.from(jobs.values()), null, 2), "utf8");
   } catch {
   }
 }
 function loadJobs() {
   try {
-    if (!fs45.existsSync(DATA_FILE)) return;
-    const data = JSON.parse(fs45.readFileSync(DATA_FILE, "utf8"));
+    if (!fs47.existsSync(DATA_FILE)) return;
+    const data = JSON.parse(fs47.readFileSync(DATA_FILE, "utf8"));
     for (const job of data) {
       jobs.set(job.id, job);
       const num = parseInt(job.id, 10);
@@ -390626,17 +391044,17 @@ async function triggerJob(id) {
     return false;
   }
 }
-var fs45, path47, os4, jobs, timers, jobSeq, DATA_DIR, DATA_FILE;
+var fs47, path49, os5, jobs, timers, jobSeq, DATA_DIR, DATA_FILE;
 var init_cronManager = __esm({
   "core/cronManager.ts"() {
-    fs45 = __toESM(require("fs"));
-    path47 = __toESM(require("path"));
-    os4 = __toESM(require("os"));
+    fs47 = __toESM(require("fs"));
+    path49 = __toESM(require("path"));
+    os5 = __toESM(require("os"));
     jobs = /* @__PURE__ */ new Map();
     timers = /* @__PURE__ */ new Map();
     jobSeq = 1;
-    DATA_DIR = path47.join(os4.homedir(), ".aiden");
-    DATA_FILE = path47.join(DATA_DIR, "cron_jobs.json");
+    DATA_DIR = path49.join(os5.homedir(), ".aiden");
+    DATA_FILE = path49.join(DATA_DIR, "cron_jobs.json");
   }
 });
 
@@ -390662,10 +391080,10 @@ async function analyzeImage(imageSource, prompt = "Describe this image in detail
   let base64Data = "";
   let mediaType = "image/jpeg";
   if (!isUrl) {
-    const absPath = path48.isAbsolute(imageSource) ? imageSource : path48.resolve(process.cwd(), imageSource);
-    const buf = fs46.readFileSync(absPath);
+    const absPath = path50.isAbsolute(imageSource) ? imageSource : path50.resolve(process.cwd(), imageSource);
+    const buf = fs48.readFileSync(absPath);
     base64Data = buf.toString("base64");
-    mediaType = extToMediaType(path48.extname(absPath));
+    mediaType = extToMediaType(path50.extname(absPath));
   }
   const anthropicKey = process.env.ANTHROPIC_API_KEY;
   if (anthropicKey) {
@@ -390745,11 +391163,11 @@ async function analyzeImage(imageSource, prompt = "Describe this image in detail
     throw new Error(`vision_analyze: all providers exhausted. ${e.message}`);
   }
 }
-var fs46, path48;
+var fs48, path50;
 var init_visionAnalyze = __esm({
   "core/visionAnalyze.ts"() {
-    fs46 = __toESM(require("fs"));
-    path48 = __toESM(require("path"));
+    fs48 = __toESM(require("fs"));
+    path50 = __toESM(require("path"));
     init_axios2();
   }
 });
@@ -390757,9 +391175,9 @@ var init_visionAnalyze = __esm({
 // core/dreamEngine.ts
 function acquireLock() {
   try {
-    import_fs40.default.mkdirSync(import_path42.default.dirname(LOCK_FILE), { recursive: true });
-    if (import_fs40.default.existsSync(LOCK_FILE)) {
-      const raw = JSON.parse(import_fs40.default.readFileSync(LOCK_FILE, "utf-8"));
+    import_fs41.default.mkdirSync(import_path43.default.dirname(LOCK_FILE), { recursive: true });
+    if (import_fs41.default.existsSync(LOCK_FILE)) {
+      const raw = JSON.parse(import_fs41.default.readFileSync(LOCK_FILE, "utf-8"));
       const alive = isPidAlive(raw.pid);
       if (alive) {
         console.log(`[DreamEngine] Lock held by PID ${raw.pid} \u2014 skipping`);
@@ -390768,7 +391186,7 @@ function acquireLock() {
       console.log(`[DreamEngine] Stale lock (PID ${raw.pid} dead) \u2014 stealing`);
     }
     const data = { pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString() };
-    import_fs40.default.writeFileSync(LOCK_FILE, JSON.stringify(data));
+    import_fs41.default.writeFileSync(LOCK_FILE, JSON.stringify(data));
     return true;
   } catch {
     return false;
@@ -390778,9 +391196,9 @@ function releaseLock(prevMtime) {
   try {
     if (prevMtime !== void 0) {
       const now = Date.now() / 1e3;
-      import_fs40.default.utimesSync(LOCK_FILE, now, now);
+      import_fs41.default.utimesSync(LOCK_FILE, now, now);
     } else {
-      import_fs40.default.unlinkSync(LOCK_FILE);
+      import_fs41.default.unlinkSync(LOCK_FILE);
     }
   } catch {
   }
@@ -390795,8 +391213,8 @@ function isPidAlive(pid) {
 }
 function getLockMtime() {
   try {
-    if (!import_fs40.default.existsSync(LOCK_FILE)) return 0;
-    return import_fs40.default.statSync(LOCK_FILE).mtimeMs;
+    if (!import_fs41.default.existsSync(LOCK_FILE)) return 0;
+    return import_fs41.default.statSync(LOCK_FILE).mtimeMs;
   } catch {
     return 0;
   }
@@ -390808,11 +391226,11 @@ function checkTimeGate(lockMtime) {
 }
 function checkSessionGate(lockMtime) {
   try {
-    if (!import_fs40.default.existsSync(SESSIONS_DIR3)) return false;
+    if (!import_fs41.default.existsSync(SESSIONS_DIR3)) return false;
     const cutoff = lockMtime || 0;
-    const newSessions = import_fs40.default.readdirSync(SESSIONS_DIR3).filter((f) => f.endsWith(".md")).filter((f) => {
+    const newSessions = import_fs41.default.readdirSync(SESSIONS_DIR3).filter((f) => f.endsWith(".md")).filter((f) => {
       try {
-        return import_fs40.default.statSync(import_path42.default.join(SESSIONS_DIR3, f)).mtimeMs > cutoff;
+        return import_fs41.default.statSync(import_path43.default.join(SESSIONS_DIR3, f)).mtimeMs > cutoff;
       } catch {
         return false;
       }
@@ -390828,8 +391246,8 @@ function allGatesPass() {
 }
 async function phaseOrient() {
   try {
-    const indexContent = import_fs40.default.existsSync(INDEX_PATH2) ? import_fs40.default.readFileSync(INDEX_PATH2, "utf-8") : "(empty)";
-    const memFiles = import_fs40.default.existsSync(MEMORY_DIR3) ? import_fs40.default.readdirSync(MEMORY_DIR3).filter((f) => f.endsWith(".md") && f !== "MEMORY_INDEX.md") : [];
+    const indexContent = import_fs41.default.existsSync(INDEX_PATH2) ? import_fs41.default.readFileSync(INDEX_PATH2, "utf-8") : "(empty)";
+    const memFiles = import_fs41.default.existsSync(MEMORY_DIR3) ? import_fs41.default.readdirSync(MEMORY_DIR3).filter((f) => f.endsWith(".md") && f !== "MEMORY_INDEX.md") : [];
     return `MEMORY DIRECTORY (${memFiles.length} files):
 ${memFiles.join("\n")}
 
@@ -390841,10 +391259,10 @@ ${indexContent.slice(0, 2e3)}`;
 }
 async function phaseGather(lockMtime) {
   try {
-    if (!import_fs40.default.existsSync(SESSIONS_DIR3)) return "(no sessions)";
-    const recentSessions = import_fs40.default.readdirSync(SESSIONS_DIR3).filter((f) => f.endsWith(".md")).filter((f) => {
+    if (!import_fs41.default.existsSync(SESSIONS_DIR3)) return "(no sessions)";
+    const recentSessions = import_fs41.default.readdirSync(SESSIONS_DIR3).filter((f) => f.endsWith(".md")).filter((f) => {
       try {
-        return import_fs40.default.statSync(import_path42.default.join(SESSIONS_DIR3, f)).mtimeMs > lockMtime;
+        return import_fs41.default.statSync(import_path43.default.join(SESSIONS_DIR3, f)).mtimeMs > lockMtime;
       } catch {
         return false;
       }
@@ -390852,7 +391270,7 @@ async function phaseGather(lockMtime) {
     if (recentSessions.length === 0) return "(no new sessions)";
     const excerpts = recentSessions.map((f) => {
       try {
-        const content = import_fs40.default.readFileSync(import_path42.default.join(SESSIONS_DIR3, f), "utf-8");
+        const content = import_fs41.default.readFileSync(import_path43.default.join(SESSIONS_DIR3, f), "utf-8");
         return `=== ${f} ===
 ${content.slice(0, 800)}`;
       } catch {
@@ -390902,11 +391320,11 @@ Rules:
     const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     for (const item of items) {
       if (!item.filename || !item.content) continue;
-      const filePath = import_path42.default.join(MEMORY_DIR3, item.filename);
+      const filePath = import_path43.default.join(MEMORY_DIR3, item.filename);
       let created = now;
-      if (import_fs40.default.existsSync(filePath)) {
+      if (import_fs41.default.existsSync(filePath)) {
         try {
-          const existing = import_fs40.default.readFileSync(filePath, "utf-8");
+          const existing = import_fs41.default.readFileSync(filePath, "utf-8");
           const m2 = existing.match(/^created:\s*(.+)$/m);
           if (m2) created = m2[1].trim();
         } catch {
@@ -390922,7 +391340,7 @@ updated: ${now}
 ${item.content.trim()}
 `;
       try {
-        import_fs40.default.writeFileSync(filePath, fileContent, "utf-8");
+        import_fs41.default.writeFileSync(filePath, fileContent, "utf-8");
         filesUpdated++;
       } catch {
       }
@@ -390935,10 +391353,10 @@ ${item.content.trim()}
 }
 async function phasePrune(filesUpdated) {
   try {
-    if (!import_fs40.default.existsSync(MEMORY_DIR3)) return;
-    const files = import_fs40.default.readdirSync(MEMORY_DIR3).filter((f) => f.endsWith(".md") && f !== "MEMORY_INDEX.md").map((f) => {
+    if (!import_fs41.default.existsSync(MEMORY_DIR3)) return;
+    const files = import_fs41.default.readdirSync(MEMORY_DIR3).filter((f) => f.endsWith(".md") && f !== "MEMORY_INDEX.md").map((f) => {
       try {
-        const content = import_fs40.default.readFileSync(import_path42.default.join(MEMORY_DIR3, f), "utf-8");
+        const content = import_fs41.default.readFileSync(import_path43.default.join(MEMORY_DIR3, f), "utf-8");
         const titleM = content.match(/^title:\s*(.+)$/m);
         const sumM = content.match(/---\n+([\s\S]+?)(?:\n\n|$)/);
         const title = titleM ? titleM[1].trim() : f.replace(".md", "");
@@ -390948,7 +391366,7 @@ async function phasePrune(filesUpdated) {
         return null;
       }
     }).filter((l2) => l2 !== null).slice(0, 100);
-    import_fs40.default.writeFileSync(INDEX_PATH2, files.join("\n") + "\n", "utf-8");
+    import_fs41.default.writeFileSync(INDEX_PATH2, files.join("\n") + "\n", "utf-8");
     console.log(`[DreamEngine] Pruned index to ${files.length} entries (${filesUpdated} files updated)`);
   } catch (e) {
     console.error("[DreamEngine] Prune phase failed:", e.message);
@@ -390966,7 +391384,7 @@ async function runDream() {
   let sessionsReviewed = 0;
   let filesUpdated = 0;
   try {
-    import_fs40.default.mkdirSync(MEMORY_DIR3, { recursive: true });
+    import_fs41.default.mkdirSync(MEMORY_DIR3, { recursive: true });
     console.log("[DreamEngine] Phase 1: Orient");
     const orientData = await phaseOrient();
     console.log("[DreamEngine] Phase 2: Gather");
@@ -390996,9 +391414,9 @@ async function runDream() {
     try {
       if (prevMtime > 0) {
         const t = prevMtime / 1e3;
-        import_fs40.default.utimesSync(LOCK_FILE, t, t);
+        import_fs41.default.utimesSync(LOCK_FILE, t, t);
       } else {
-        import_fs40.default.unlinkSync(LOCK_FILE);
+        import_fs41.default.unlinkSync(LOCK_FILE);
       }
     } catch {
     }
@@ -391008,17 +391426,17 @@ function checkAndRunDream() {
   if (!allGatesPass()) return;
   runDream().catch((e) => console.error("[DreamEngine] Unhandled error:", e.message));
 }
-var import_fs40, import_path42, LOCK_FILE, MEMORY_DIR3, SESSIONS_DIR3, INDEX_PATH2, GATE_HOURS, GATE_SESSIONS;
+var import_fs41, import_path43, LOCK_FILE, MEMORY_DIR3, SESSIONS_DIR3, INDEX_PATH2, GATE_HOURS, GATE_SESSIONS;
 var init_dreamEngine = __esm({
   "core/dreamEngine.ts"() {
-    import_fs40 = __toESM(require("fs"));
-    import_path42 = __toESM(require("path"));
+    import_fs41 = __toESM(require("fs"));
+    import_path43 = __toESM(require("path"));
     init_auxiliaryClient();
     init_auditTrail();
-    LOCK_FILE = import_path42.default.join(process.cwd(), "workspace", "dream.lock");
-    MEMORY_DIR3 = import_path42.default.join(process.cwd(), "workspace", "memory");
-    SESSIONS_DIR3 = import_path42.default.join(process.cwd(), "workspace", "sessions");
-    INDEX_PATH2 = import_path42.default.join(MEMORY_DIR3, "MEMORY_INDEX.md");
+    LOCK_FILE = import_path43.default.join(process.cwd(), "workspace", "dream.lock");
+    MEMORY_DIR3 = import_path43.default.join(process.cwd(), "workspace", "memory");
+    SESSIONS_DIR3 = import_path43.default.join(process.cwd(), "workspace", "sessions");
+    INDEX_PATH2 = import_path43.default.join(MEMORY_DIR3, "MEMORY_INDEX.md");
     GATE_HOURS = 24;
     GATE_SESSIONS = 5;
   }
@@ -391031,11 +391449,11 @@ __export(patternDetector_exports, {
   getPatternSummary: () => getPatternSummary
 });
 async function detectPatterns() {
-  if (!(0, import_fs41.existsSync)(SESSION_DIR)) return [];
+  if (!(0, import_fs42.existsSync)(SESSION_DIR)) return [];
   const messages = [];
-  for (const file of (0, import_fs41.readdirSync)(SESSION_DIR).slice(-30)) {
+  for (const file of (0, import_fs42.readdirSync)(SESSION_DIR).slice(-30)) {
     try {
-      const content = (0, import_fs41.readFileSync)((0, import_path43.join)(SESSION_DIR, file), "utf8");
+      const content = (0, import_fs42.readFileSync)((0, import_path44.join)(SESSION_DIR, file), "utf8");
       if (file.endsWith(".json")) {
         const session = JSON.parse(content);
         (session.messages ?? []).filter((m2) => m2.role === "user").forEach((m2) => messages.push({
@@ -391071,12 +391489,12 @@ function getPatternSummary(patterns) {
   if (patterns.length === 0) return "";
   return "Detected usage patterns:\n" + patterns.slice(0, 3).map((p) => `- ${p.description} (${p.frequency})`).join("\n");
 }
-var import_fs41, import_path43, SESSION_DIR;
+var import_fs42, import_path44, SESSION_DIR;
 var init_patternDetector = __esm({
   "core/patternDetector.ts"() {
-    import_fs41 = require("fs");
-    import_path43 = require("path");
-    SESSION_DIR = (0, import_path43.join)(process.cwd(), "workspace", "sessions");
+    import_fs42 = require("fs");
+    import_path44 = require("path");
+    SESSION_DIR = (0, import_path44.join)(process.cwd(), "workspace", "sessions");
   }
 });
 
@@ -391094,8 +391512,8 @@ __export(scheduler_exports, {
 function loadHeartbeatConfig() {
   const isDebug = (process.env.AIDEN_LOG_LEVEL || "info") === "debug";
   try {
-    if (!import_fs42.default.existsSync(HEARTBEAT_PATH)) return;
-    const content = import_fs42.default.readFileSync(HEARTBEAT_PATH, "utf-8");
+    if (!import_fs43.default.existsSync(HEARTBEAT_PATH)) return;
+    const content = import_fs43.default.readFileSync(HEARTBEAT_PATH, "utf-8");
     const sections = content.split(/^## /m).slice(1);
     let loaded = 0;
     for (const section of sections) {
@@ -391190,8 +391608,8 @@ function cronMatchesNow(cronExpr) {
 }
 function _rsave() {
   try {
-    if (!import_fs42.default.existsSync(_RDATA_DIR)) import_fs42.default.mkdirSync(_RDATA_DIR, { recursive: true });
-    import_fs42.default.writeFileSync(_RDATA_FILE, JSON.stringify(Array.from(_reminders.values()), null, 2), "utf8");
+    if (!import_fs43.default.existsSync(_RDATA_DIR)) import_fs43.default.mkdirSync(_RDATA_DIR, { recursive: true });
+    import_fs43.default.writeFileSync(_RDATA_FILE, JSON.stringify(Array.from(_reminders.values()), null, 2), "utf8");
   } catch {
   }
 }
@@ -391249,11 +391667,11 @@ function cancelReminder(id) {
 }
 function initReminderScheduler() {
   try {
-    if (!import_fs42.default.existsSync(_RDATA_FILE)) {
+    if (!import_fs43.default.existsSync(_RDATA_FILE)) {
       console.log("[Reminders] No saved reminders");
       return;
     }
-    const stored = JSON.parse(import_fs42.default.readFileSync(_RDATA_FILE, "utf8"));
+    const stored = JSON.parse(import_fs43.default.readFileSync(_RDATA_FILE, "utf8"));
     const now = Date.now();
     let loaded = 0;
     for (const r of stored) {
@@ -391273,18 +391691,18 @@ function initReminderScheduler() {
     console.error("[Reminders] Init error:", e.message);
   }
 }
-var import_fs42, import_path44, os5, TASKS_PATH, HEARTBEAT_PATH, Scheduler, scheduler, _reminders, _rtimers, _rseq, _RDATA_DIR, _RDATA_FILE;
+var import_fs43, import_path45, os6, TASKS_PATH, HEARTBEAT_PATH, Scheduler, scheduler, _reminders, _rtimers, _rseq, _RDATA_DIR, _RDATA_FILE;
 var init_scheduler = __esm({
   "core/scheduler.ts"() {
-    import_fs42 = __toESM(require("fs"));
-    import_path44 = __toESM(require("path"));
+    import_fs43 = __toESM(require("fs"));
+    import_path45 = __toESM(require("path"));
     init_morningBriefing();
     init_dreamEngine();
     init_goalTracker();
     init_patternDetector();
-    os5 = __toESM(require("os"));
-    TASKS_PATH = import_path44.default.join(process.cwd(), "workspace", "scheduled-tasks.json");
-    HEARTBEAT_PATH = import_path44.default.join(process.cwd(), "workspace", "HEARTBEAT.md");
+    os6 = __toESM(require("os"));
+    TASKS_PATH = import_path45.default.join(process.cwd(), "workspace", "scheduled-tasks.json");
+    HEARTBEAT_PATH = import_path45.default.join(process.cwd(), "workspace", "HEARTBEAT.md");
     Scheduler = class _Scheduler {
       constructor() {
         this.tasks = [];
@@ -391351,8 +391769,8 @@ var init_scheduler = __esm({
           const ACTIVE_START = 8;
           const ACTIVE_END = 23;
           if (hour < ACTIVE_START || hour >= ACTIVE_END) return;
-          if (!import_fs42.default.existsSync(HEARTBEAT_PATH)) return;
-          const checklist = import_fs42.default.readFileSync(HEARTBEAT_PATH, "utf-8").trim();
+          if (!import_fs43.default.existsSync(HEARTBEAT_PATH)) return;
+          const checklist = import_fs43.default.readFileSync(HEARTBEAT_PATH, "utf-8").trim();
           if (!checklist) return;
           let heartbeatPrompt = checklist;
           const goalsSummary = getActiveGoalsSummary();
@@ -391493,8 +391911,8 @@ var init_scheduler = __esm({
       }
       load() {
         try {
-          if (!import_fs42.default.existsSync(TASKS_PATH)) return;
-          const raw = import_fs42.default.readFileSync(TASKS_PATH, "utf-8");
+          if (!import_fs43.default.existsSync(TASKS_PATH)) return;
+          const raw = import_fs43.default.readFileSync(TASKS_PATH, "utf-8");
           this.tasks = JSON.parse(raw);
           const enabled = this.tasks.filter((t) => t.enabled);
           enabled.forEach((t) => this.scheduleTask(t));
@@ -391508,8 +391926,8 @@ var init_scheduler = __esm({
       }
       save() {
         try {
-          import_fs42.default.mkdirSync(import_path44.default.dirname(TASKS_PATH), { recursive: true });
-          import_fs42.default.writeFileSync(TASKS_PATH, JSON.stringify(this.tasks, null, 2));
+          import_fs43.default.mkdirSync(import_path45.default.dirname(TASKS_PATH), { recursive: true });
+          import_fs43.default.writeFileSync(TASKS_PATH, JSON.stringify(this.tasks, null, 2));
         } catch (e) {
           console.warn(`[Scheduler] Failed to save tasks: ${e.message}`);
         }
@@ -391519,8 +391937,8 @@ var init_scheduler = __esm({
     _reminders = /* @__PURE__ */ new Map();
     _rtimers = /* @__PURE__ */ new Map();
     _rseq = 1;
-    _RDATA_DIR = import_path44.default.join(os5.homedir(), ".aiden");
-    _RDATA_FILE = import_path44.default.join(_RDATA_DIR, "scheduled.json");
+    _RDATA_DIR = import_path45.default.join(os6.homedir(), ".aiden");
+    _RDATA_FILE = import_path45.default.join(_RDATA_DIR, "scheduled.json");
   }
 });
 
@@ -391601,15 +392019,15 @@ function isCommandAllowed(cmd) {
   return { allowed: false, needsApproval: true };
 }
 function cleanOldBrowserProfiles() {
-  if (!import_fs43.default.existsSync(BROWSER_DATA_DIR)) return;
+  if (!import_fs44.default.existsSync(BROWSER_DATA_DIR)) return;
   const cutoff = Date.now() - 24 * 60 * 60 * 1e3;
   try {
-    for (const entry of import_fs43.default.readdirSync(BROWSER_DATA_DIR)) {
-      const fullPath = import_path45.default.join(BROWSER_DATA_DIR, entry);
+    for (const entry of import_fs44.default.readdirSync(BROWSER_DATA_DIR)) {
+      const fullPath = import_path46.default.join(BROWSER_DATA_DIR, entry);
       try {
-        const stat = import_fs43.default.statSync(fullPath);
+        const stat = import_fs44.default.statSync(fullPath);
         if (stat.mtimeMs < cutoff) {
-          import_fs43.default.rmSync(fullPath, { recursive: true, force: true });
+          import_fs44.default.rmSync(fullPath, { recursive: true, force: true });
           console.log(`[Browser] Cleaned old profile: ${entry}`);
         }
       } catch {
@@ -391639,15 +392057,15 @@ function setProgressEmitter(fn) {
   _emitProgress = fn;
 }
 function resolveWritePath(rawPath, opts) {
-  const home = opts?.home ?? import_os4.default.homedir();
+  const home = opts?.home ?? import_os5.default.homedir();
   const cwd = opts?.cwd ?? process.cwd();
-  const user = process.env.USERNAME || process.env.USER || import_os4.default.userInfo().username || "User";
-  let p = rawPath.replace(/^~[\/\\]/, home + import_path45.default.sep).replace(/^Desktop[\/\\]/i, import_path45.default.join(home, "Desktop") + import_path45.default.sep).replace(/^C:\\Users\\Aiden\\/i, `C:\\Users\\${user}\\`).replace(/^C:\/Users\/Aiden\//i, `C:/Users/${user}/`);
-  const resolved = /^[A-Za-z]:[/\\]/.test(p) || p.startsWith("/") ? p : import_path45.default.join(cwd, p);
+  const user = process.env.USERNAME || process.env.USER || import_os5.default.userInfo().username || "User";
+  let p = rawPath.replace(/^~[\/\\]/, home + import_path46.default.sep).replace(/^Desktop[\/\\]/i, import_path46.default.join(home, "Desktop") + import_path46.default.sep).replace(/^C:\\Users\\Aiden\\/i, `C:\\Users\\${user}\\`).replace(/^C:\/Users\/Aiden\//i, `C:/Users/${user}/`);
+  const resolved = /^[A-Za-z]:[/\\]/.test(p) || p.startsWith("/") ? p : import_path46.default.join(cwd, p);
   const allowedRoots = [
     cwd,
-    import_path45.default.join(home, "Desktop"),
-    import_path45.default.join(home, "Documents")
+    import_path46.default.join(home, "Desktop"),
+    import_path46.default.join(home, "Documents")
   ];
   const norm = (s) => s.toLowerCase().replace(/\//g, "\\").replace(/\\$/, "");
   const nr = norm(resolved);
@@ -391882,14 +392300,14 @@ function getToolsForCategories(categories) {
   }
   return Array.from(tools);
 }
-var import_child_process13, import_util10, import_fs43, import_path45, import_os4, import_minimatch2, execAsync8, PROTECTED_FILES2, DENIED_PATHS, DENIED_COMMANDS, activeWatchers, SHELL_DANGEROUS_PATTERNS, PROTECTED_PATH_PATTERNS, CODE_DESTRUCTIVE_NODE, CODE_DESTRUCTIVE_PYTHON, SHELL_ALLOWLIST, BROWSER_DATA_DIR, TOOL_TIMEOUTS, _emitProgress, APP_ALIASES, DISPLAY_ALIASES, TOOLS, externalTools, externalToolsMeta, _generation, TOOL_DESCRIPTIONS, TOOL_NAMES_ONLY, TOOL_TIERS, TOOL_CATEGORIES, TOOL_REGISTRY, registryNames, registryDescriptions, registryTiers, registryCategories, registryTimeouts, registryAllowedTools, registryValidTools, registryNoRetrySet, registryParallelSafeSet, registrySequentialOnlySet, registryMcpSafeList, registryMcpDestructiveList;
+var import_child_process13, import_util10, import_fs44, import_path46, import_os5, import_minimatch2, execAsync8, PROTECTED_FILES2, DENIED_PATHS, DENIED_COMMANDS, activeWatchers, SHELL_DANGEROUS_PATTERNS, PROTECTED_PATH_PATTERNS, CODE_DESTRUCTIVE_NODE, CODE_DESTRUCTIVE_PYTHON, SHELL_ALLOWLIST, BROWSER_DATA_DIR, TOOL_TIMEOUTS, _emitProgress, APP_ALIASES, DISPLAY_ALIASES, TOOLS, externalTools, externalToolsMeta, _generation, TOOL_DESCRIPTIONS, TOOL_NAMES_ONLY, TOOL_TIERS, TOOL_CATEGORIES, TOOL_REGISTRY, registryNames, registryDescriptions, registryTiers, registryCategories, registryTimeouts, registryAllowedTools, registryValidTools, registryNoRetrySet, registryParallelSafeSet, registrySequentialOnlySet, registryMcpSafeList, registryMcpDestructiveList;
 var init_toolRegistry = __esm({
   "core/toolRegistry.ts"() {
     import_child_process13 = require("child_process");
     import_util10 = require("util");
-    import_fs43 = __toESM(require("fs"));
-    import_path45 = __toESM(require("path"));
-    import_os4 = __toESM(require("os"));
+    import_fs44 = __toESM(require("fs"));
+    import_path46 = __toESM(require("path"));
+    import_os5 = __toESM(require("os"));
     init_paths();
     init_computerControl();
     init_webSearch();
@@ -392061,7 +392479,7 @@ var init_toolRegistry = __esm({
       // 16. Windows window management
       /^(start|explorer)\b/i
     ];
-    BROWSER_DATA_DIR = import_path45.default.join(getUserDataDir(), "browser-profiles");
+    BROWSER_DATA_DIR = import_path46.default.join(getUserDataDir(), "browser-profiles");
     try {
       cleanOldBrowserProfiles();
     } catch {
@@ -392404,9 +392822,9 @@ stderr: ${sr.stderr}` : "")).trim() || "(completed)";
             return { success: false, output: "", error: "Blocked: this command pattern is not allowed. Dangerous operations require explicit user approval." };
           }
         }
-        const tmpFile = import_path45.default.join(process.cwd(), "workspace", `tmp_${Date.now()}.ps1`);
-        import_fs43.default.mkdirSync(import_path45.default.dirname(tmpFile), { recursive: true });
-        import_fs43.default.writeFileSync(tmpFile, script2);
+        const tmpFile = import_path46.default.join(process.cwd(), "workspace", `tmp_${Date.now()}.ps1`);
+        import_fs44.default.mkdirSync(import_path46.default.dirname(tmpFile), { recursive: true });
+        import_fs44.default.writeFileSync(tmpFile, script2);
         try {
           const { stdout, stderr } = await execAsync8(
             `powershell.exe -ExecutionPolicy Bypass -File "${tmpFile}"`,
@@ -392417,7 +392835,7 @@ stderr: ${sr.stderr}` : "")).trim() || "(completed)";
           return { success: false, output: "", error: e.message };
         } finally {
           try {
-            import_fs43.default.unlinkSync(tmpFile);
+            import_fs44.default.unlinkSync(tmpFile);
           } catch {
           }
         }
@@ -392521,9 +392939,9 @@ stderr: ${sr.stderr}` : "")).trim() || "(completed)";
         }
         try {
           const resolved = resolveWritePath(filePath);
-          import_fs43.default.mkdirSync(import_path45.default.dirname(resolved), { recursive: true });
-          import_fs43.default.writeFileSync(resolved, content, "utf-8");
-          const written = import_fs43.default.existsSync(resolved);
+          import_fs44.default.mkdirSync(import_path46.default.dirname(resolved), { recursive: true });
+          import_fs44.default.writeFileSync(resolved, content, "utf-8");
+          const written = import_fs44.default.existsSync(resolved);
           return {
             success: written,
             output: written ? `Written and verified: ${resolved} (${content.length} chars)` : "Write failed"
@@ -392547,10 +392965,10 @@ stderr: ${sr.stderr}` : "")).trim() || "(completed)";
         try {
           const _user = process.env.USERNAME || process.env.USER || require("os").userInfo().username || "User";
           const _home = require("os").homedir();
-          filePath = filePath.replace(/^~[\/\\]/i, _home + import_path45.default.sep).replace(/^Desktop[\/\\]/i, import_path45.default.join(_home, "Desktop") + import_path45.default.sep).replace(/^C:\\Users\\Aiden\\/i, `C:\\Users\\${_user}\\`).replace(/^C:\/Users\/Aiden\//i, `C:/Users/${_user}/`);
-          const resolved = filePath.match(/^[A-Z]:/i) || filePath.startsWith("/") ? filePath : import_path45.default.join(process.cwd(), filePath);
-          if (!import_fs43.default.existsSync(resolved)) return { success: false, output: "", error: `Not found: ${resolved}` };
-          return { success: true, output: import_fs43.default.readFileSync(resolved, "utf-8").slice(0, 5e3) };
+          filePath = filePath.replace(/^~[\/\\]/i, _home + import_path46.default.sep).replace(/^Desktop[\/\\]/i, import_path46.default.join(_home, "Desktop") + import_path46.default.sep).replace(/^C:\\Users\\Aiden\\/i, `C:\\Users\\${_user}\\`).replace(/^C:\/Users\/Aiden\//i, `C:/Users/${_user}/`);
+          const resolved = filePath.match(/^[A-Z]:/i) || filePath.startsWith("/") ? filePath : import_path46.default.join(process.cwd(), filePath);
+          if (!import_fs44.default.existsSync(resolved)) return { success: false, output: "", error: `Not found: ${resolved}` };
+          return { success: true, output: import_fs44.default.readFileSync(resolved, "utf-8").slice(0, 5e3) };
         } catch (e) {
           return { success: false, output: "", error: e.message };
         }
@@ -392560,9 +392978,9 @@ stderr: ${sr.stderr}` : "")).trim() || "(completed)";
         try {
           const _user = process.env.USERNAME || process.env.USER || require("os").userInfo().username || "User";
           const _home = require("os").homedir();
-          dirPath = dirPath.replace(/^~[\/\\]/i, _home + import_path45.default.sep).replace(/^Desktop[\/\\]?$/i, import_path45.default.join(_home, "Desktop")).replace(/^Desktop[\/\\]/i, import_path45.default.join(_home, "Desktop") + import_path45.default.sep).replace(/^C:\\Users\\Aiden\\/i, `C:\\Users\\${_user}\\`).replace(/^C:\/Users\/Aiden\//i, `C:/Users/${_user}/`);
-          const resolved = dirPath.match(/^[A-Z]:/i) ? dirPath : import_path45.default.join(process.cwd(), dirPath);
-          return { success: true, output: import_fs43.default.readdirSync(resolved).join("\n") };
+          dirPath = dirPath.replace(/^~[\/\\]/i, _home + import_path46.default.sep).replace(/^Desktop[\/\\]?$/i, import_path46.default.join(_home, "Desktop")).replace(/^Desktop[\/\\]/i, import_path46.default.join(_home, "Desktop") + import_path46.default.sep).replace(/^C:\\Users\\Aiden\\/i, `C:\\Users\\${_user}\\`).replace(/^C:\/Users\/Aiden\//i, `C:/Users/${_user}/`);
+          const resolved = dirPath.match(/^[A-Z]:/i) ? dirPath : import_path46.default.join(process.cwd(), dirPath);
+          return { success: true, output: import_fs44.default.readdirSync(resolved).join("\n") };
         } catch (e) {
           return { success: false, output: "", error: e.message };
         }
@@ -392584,9 +393002,9 @@ stderr: ${sr.stderr}` : "")).trim() || "Script completed with no output";
             console.warn("[Sandbox] auto-mode fell back to host:", sandboxErr.message);
           }
         }
-        const tmp = import_path45.default.join(process.cwd(), "workspace", `py_${Date.now()}.py`);
-        import_fs43.default.mkdirSync(import_path45.default.dirname(tmp), { recursive: true });
-        import_fs43.default.writeFileSync(tmp, script2);
+        const tmp = import_path46.default.join(process.cwd(), "workspace", `py_${Date.now()}.py`);
+        import_fs44.default.mkdirSync(import_path46.default.dirname(tmp), { recursive: true });
+        import_fs44.default.writeFileSync(tmp, script2);
         const showProgress = process.env.AIDEN_SHOW_TOOL_OUTPUT !== "false";
         return new Promise((resolve8) => {
           let stdout = "";
@@ -392612,7 +393030,7 @@ stderr: ${sr.stderr}` : "")).trim() || "Script completed with no output";
           proc.on("close", (code) => {
             clearTimeout(timer);
             try {
-              import_fs43.default.unlinkSync(tmp);
+              import_fs44.default.unlinkSync(tmp);
             } catch {
             }
             const output = (stdout || stderr || "").trim() || "Script completed with no output";
@@ -392625,9 +393043,9 @@ stderr: ${sr.stderr}` : "")).trim() || "Script completed with no output";
         if (!script2) return { success: false, output: "", error: "No script" };
         const nodeGuard = scanCodeForDestructivePaths(script2, "node");
         if (nodeGuard.denied) return { success: false, output: "", error: nodeGuard.reason };
-        const tmp = import_path45.default.join(process.cwd(), "workspace", `js_${Date.now()}.js`);
-        import_fs43.default.mkdirSync(import_path45.default.dirname(tmp), { recursive: true });
-        import_fs43.default.writeFileSync(tmp, script2);
+        const tmp = import_path46.default.join(process.cwd(), "workspace", `js_${Date.now()}.js`);
+        import_fs44.default.mkdirSync(import_path46.default.dirname(tmp), { recursive: true });
+        import_fs44.default.writeFileSync(tmp, script2);
         try {
           const { stdout, stderr } = await execAsync8(`node "${tmp}"`, {
             timeout: 6e4,
@@ -392638,7 +393056,7 @@ stderr: ${sr.stderr}` : "")).trim() || "Script completed with no output";
           return { success: false, output: e.stdout || "", error: `Node error: ${e.message}` };
         } finally {
           try {
-            import_fs43.default.unlinkSync(tmp);
+            import_fs44.default.unlinkSync(tmp);
           } catch {
           }
         }
@@ -393455,7 +393873,7 @@ public class AidenVolSet {
         const stop = !!p.stop;
         if (!rawFolder) return { success: false, output: "", error: "No folder specified" };
         const userName = process.env.USERPROFILE || process.env.HOME || "";
-        const folderPath = rawFolder.replace(/%USERPROFILE%/gi, userName).replace(/^~[\/\\]/, userName + import_path45.default.sep);
+        const folderPath = rawFolder.replace(/%USERPROFILE%/gi, userName).replace(/^~[\/\\]/, userName + import_path46.default.sep);
         if (stop) {
           const watcher2 = activeWatchers.get(folderPath);
           if (watcher2) {
@@ -393466,20 +393884,20 @@ public class AidenVolSet {
           return { success: false, output: `No active watcher for: ${folderPath}` };
         }
         if (!goal) return { success: false, output: "", error: "No goal specified" };
-        if (!import_fs43.default.existsSync(folderPath)) return { success: false, output: "", error: `Folder not found: ${folderPath}` };
+        if (!import_fs44.default.existsSync(folderPath)) return { success: false, output: "", error: `Folder not found: ${folderPath}` };
         const existing = activeWatchers.get(folderPath);
         if (existing) {
           existing.close();
           activeWatchers.delete(folderPath);
         }
-        const watcher = import_fs43.default.watch(folderPath, async (eventType, filename) => {
+        const watcher = import_fs44.default.watch(folderPath, async (eventType, filename) => {
           if (eventType !== "rename" || !filename) return;
-          const fullPath = import_path45.default.join(folderPath, filename);
+          const fullPath = import_path46.default.join(folderPath, filename);
           await new Promise((r) => setTimeout(r, 500));
-          if (!import_fs43.default.existsSync(fullPath)) return;
+          if (!import_fs44.default.existsSync(fullPath)) return;
           let isFile2 = false;
           try {
-            isFile2 = import_fs43.default.statSync(fullPath).isFile();
+            isFile2 = import_fs44.default.statSync(fullPath).isFile();
           } catch {
             return;
           }
@@ -393750,28 +394168,28 @@ ${formatted}` };
           });
           return 2 * n / (sa.size + sb.size + 1e-3);
         };
-        const skillFolders = ["learned", "approved", "installed"].map((f) => import_path45.default.join(cwd, "workspace", "skills", f)).filter((d) => import_fs43.default.existsSync(d));
+        const skillFolders = ["learned", "approved", "installed"].map((f) => import_path46.default.join(cwd, "workspace", "skills", f)).filter((d) => import_fs44.default.existsSync(d));
         if (skillFolders.length === 0) return { success: false, output: "", error: "No skills yet" };
         let best = { score: 0, dir: "", name: "" };
         for (const folder of skillFolders) {
-          for (const entry of import_fs43.default.readdirSync(folder, { withFileTypes: true })) {
+          for (const entry of import_fs44.default.readdirSync(folder, { withFileTypes: true })) {
             if (!entry.isDirectory()) continue;
-            const metaPath2 = import_path45.default.join(folder, entry.name, "meta.json");
+            const metaPath2 = import_path46.default.join(folder, entry.name, "meta.json");
             let taskPattern = entry.name;
             try {
-              const meta = JSON.parse(import_fs43.default.readFileSync(metaPath2, "utf-8"));
+              const meta = JSON.parse(import_fs44.default.readFileSync(metaPath2, "utf-8"));
               taskPattern = meta.taskPattern || meta.description || entry.name;
             } catch {
             }
             const score = Math.max(dice(query, entry.name), dice(query, taskPattern));
-            if (score > best.score) best = { score, dir: import_path45.default.join(folder, entry.name), name: entry.name };
+            if (score > best.score) best = { score, dir: import_path46.default.join(folder, entry.name), name: entry.name };
           }
         }
         const THRESHOLD = 0.25;
         if (best.score < THRESHOLD) return { success: false, output: "", error: `No matching skill found (best: ${best.name} @ ${best.score.toFixed(2)})` };
-        const skillPath = import_path45.default.join(best.dir, "SKILL.md");
-        if (!import_fs43.default.existsSync(skillPath)) return { success: false, output: "", error: `Skill "${best.name}" has no SKILL.md` };
-        const content = import_fs43.default.readFileSync(skillPath, "utf-8");
+        const skillPath = import_path46.default.join(best.dir, "SKILL.md");
+        if (!import_fs44.default.existsSync(skillPath)) return { success: false, output: "", error: `Skill "${best.name}" has no SKILL.md` };
+        const content = import_fs44.default.readFileSync(skillPath, "utf-8");
         return { success: true, output: `[Skill: ${best.name} \u2014 match score ${best.score.toFixed(2)}]
 
 ${content}` };
@@ -393878,6 +394296,20 @@ ${content}` };
           return { success: false, output: "", error: e.message };
         }
       },
+      // ── memory_store — persist a fact to permanent memory ──
+      memory_store: async (p) => {
+        const fact = p.fact || p.text || p.content || "";
+        if (!fact) return { success: false, output: "", error: "No fact provided" };
+        const { toolMemoryStore: toolMemoryStore2 } = await Promise.resolve().then(() => (init_slashAsTool(), slashAsTool_exports));
+        return toolMemoryStore2(p);
+      },
+      // ── memory_forget — remove a fact from permanent memory ──
+      memory_forget: async (p) => {
+        const fact = p.fact || p.keyword || p.text || "";
+        if (!fact) return { success: false, output: "", error: "No fact provided" };
+        const { toolMemoryForget: toolMemoryForget2 } = await Promise.resolve().then(() => (init_slashAsTool(), slashAsTool_exports));
+        return toolMemoryForget2(p);
+      },
       // ── clarify — ask the user a multi-choice or free-text question mid-task ──
       clarify: async (p) => {
         const question = p.question || p.q || "";
@@ -402514,12 +402946,12 @@ function buildFrontmatter(meta) {
 async function writeSkillDraft(draft, targetDir) {
   const cwd = process.cwd();
   const id = sanitizeSkillId(draft.name);
-  const baseDir = targetDir === "installed" ? import_path52.default.join(cwd, "skills", "installed") : import_path52.default.join(cwd, "skills", "learned", "pending");
-  const dir = import_path52.default.join(baseDir, id);
-  if (import_fs50.default.existsSync(dir)) {
+  const baseDir = targetDir === "installed" ? import_path53.default.join(cwd, "skills", "installed") : import_path53.default.join(cwd, "skills", "learned", "pending");
+  const dir = import_path53.default.join(baseDir, id);
+  if (import_fs51.default.existsSync(dir)) {
     throw new Error(`Skill "${id}" already exists at ${dir}. Use a different name or delete the existing draft.`);
   }
-  import_fs50.default.mkdirSync(dir, { recursive: true });
+  import_fs51.default.mkdirSync(dir, { recursive: true });
   const frontmatter = buildFrontmatter({
     name: draft.name,
     description: draft.description,
@@ -402539,8 +402971,8 @@ async function writeSkillDraft(draft, targetDir) {
 
 ${header}${body}
 `;
-  const filePath = import_path52.default.join(dir, "SKILL.md");
-  import_fs50.default.writeFileSync(filePath, fileContent, "utf-8");
+  const filePath = import_path53.default.join(dir, "SKILL.md");
+  import_fs51.default.writeFileSync(filePath, fileContent, "utf-8");
   const meta = {
     id,
     name: draft.name,
@@ -402550,7 +402982,7 @@ ${header}${body}
     createdAt: timestamp2,
     enabled: false
   };
-  import_fs50.default.writeFileSync(import_path52.default.join(dir, "meta.json"), JSON.stringify(meta, null, 2) + "\n", "utf-8");
+  import_fs51.default.writeFileSync(import_path53.default.join(dir, "meta.json"), JSON.stringify(meta, null, 2) + "\n", "utf-8");
   const toolCalls = draft.sourceDetails?.toolCalls ?? [];
   const toolNames = Array.isArray(toolCalls) ? toolCalls.map((t) => t.tool ?? t).filter(Boolean) : [];
   const skillJson = {
@@ -402566,54 +402998,54 @@ ${header}${body}
     tags: draft.tags?.length ? draft.tags : inferTags(toolNames, draft.content),
     created: timestamp2
   };
-  import_fs50.default.writeFileSync(import_path52.default.join(dir, "skill.json"), JSON.stringify(skillJson, null, 2) + "\n", "utf-8");
+  import_fs51.default.writeFileSync(import_path53.default.join(dir, "skill.json"), JSON.stringify(skillJson, null, 2) + "\n", "utf-8");
   return { id, filePath, dir };
 }
 function approveDraft(id) {
   const cwd = process.cwd();
-  const pendDir = import_path52.default.join(cwd, "skills", "learned", "pending", id);
-  const approDir = import_path52.default.join(cwd, "skills", "learned", "approved", id);
-  if (!import_fs50.default.existsSync(pendDir)) throw new Error(`Pending skill "${id}" not found`);
-  if (import_fs50.default.existsSync(approDir)) throw new Error(`Approved skill "${id}" already exists`);
-  const skillFile = import_path52.default.join(pendDir, "SKILL.md");
-  if (import_fs50.default.existsSync(skillFile)) {
-    let content = import_fs50.default.readFileSync(skillFile, "utf-8");
+  const pendDir = import_path53.default.join(cwd, "skills", "learned", "pending", id);
+  const approDir = import_path53.default.join(cwd, "skills", "learned", "approved", id);
+  if (!import_fs51.default.existsSync(pendDir)) throw new Error(`Pending skill "${id}" not found`);
+  if (import_fs51.default.existsSync(approDir)) throw new Error(`Approved skill "${id}" already exists`);
+  const skillFile = import_path53.default.join(pendDir, "SKILL.md");
+  if (import_fs51.default.existsSync(skillFile)) {
+    let content = import_fs51.default.readFileSync(skillFile, "utf-8");
     content = content.replace(/^enabled:\s*false/m, "enabled: true");
-    import_fs50.default.writeFileSync(skillFile, content, "utf-8");
+    import_fs51.default.writeFileSync(skillFile, content, "utf-8");
   }
-  import_fs50.default.mkdirSync(import_path52.default.join(cwd, "skills", "learned", "approved"), { recursive: true });
-  import_fs50.default.renameSync(pendDir, approDir);
+  import_fs51.default.mkdirSync(import_path53.default.join(cwd, "skills", "learned", "approved"), { recursive: true });
+  import_fs51.default.renameSync(pendDir, approDir);
   return approDir;
 }
 function rejectDraft(id) {
   const cwd = process.cwd();
-  const pendDir = import_path52.default.join(cwd, "skills", "learned", "pending", id);
-  if (!import_fs50.default.existsSync(pendDir)) throw new Error(`Pending skill "${id}" not found`);
+  const pendDir = import_path53.default.join(cwd, "skills", "learned", "pending", id);
+  if (!import_fs51.default.existsSync(pendDir)) throw new Error(`Pending skill "${id}" not found`);
   let meta = { id };
   try {
-    meta = JSON.parse(import_fs50.default.readFileSync(import_path52.default.join(pendDir, "meta.json"), "utf-8"));
+    meta = JSON.parse(import_fs51.default.readFileSync(import_path53.default.join(pendDir, "meta.json"), "utf-8"));
   } catch {
   }
-  import_fs50.default.rmSync(pendDir, { recursive: true, force: true });
-  const rejLog = import_path52.default.join(cwd, "skills", "learned", ".rejected.json");
+  import_fs51.default.rmSync(pendDir, { recursive: true, force: true });
+  const rejLog = import_path53.default.join(cwd, "skills", "learned", ".rejected.json");
   let log = [];
   try {
-    log = JSON.parse(import_fs50.default.readFileSync(rejLog, "utf-8"));
+    log = JSON.parse(import_fs51.default.readFileSync(rejLog, "utf-8"));
   } catch {
   }
   log.push({ ...meta, rejectedAt: (/* @__PURE__ */ new Date()).toISOString() });
-  import_fs50.default.writeFileSync(rejLog, JSON.stringify(log, null, 2) + "\n", "utf-8");
+  import_fs51.default.writeFileSync(rejLog, JSON.stringify(log, null, 2) + "\n", "utf-8");
 }
 function setSkillEnabled(filePath, enabled) {
-  if (!import_fs50.default.existsSync(filePath)) throw new Error(`Skill file not found: ${filePath}`);
-  let content = import_fs50.default.readFileSync(filePath, "utf-8");
+  if (!import_fs51.default.existsSync(filePath)) throw new Error(`Skill file not found: ${filePath}`);
+  let content = import_fs51.default.readFileSync(filePath, "utf-8");
   if (/^enabled:/m.test(content)) {
     content = content.replace(/^enabled:\s*(true|false)/m, `enabled: ${enabled}`);
   } else {
     content = content.replace(/^(version:.+)$/m, `$1
 enabled: ${enabled}`);
   }
-  import_fs50.default.writeFileSync(filePath, content, "utf-8");
+  import_fs51.default.writeFileSync(filePath, content, "utf-8");
 }
 function tokenSimilarity(a, b) {
   const tok = (s) => new Set(
@@ -402639,22 +403071,22 @@ async function writeSkillFromTask(args) {
   if (!success || toolsUsed.length < 2) return null;
   try {
     const cwd = process.cwd();
-    const learnedDir = import_path52.default.join(cwd, "workspace", "skills", "learned");
-    import_fs50.default.mkdirSync(learnedDir, { recursive: true });
+    const learnedDir = import_path53.default.join(cwd, "workspace", "skills", "learned");
+    import_fs51.default.mkdirSync(learnedDir, { recursive: true });
     const skillName = skillNameFromMessage(userMessage);
-    if (import_fs50.default.existsSync(learnedDir)) {
-      for (const entry of import_fs50.default.readdirSync(learnedDir, { withFileTypes: true })) {
+    if (import_fs51.default.existsSync(learnedDir)) {
+      for (const entry of import_fs51.default.readdirSync(learnedDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         const existingName = entry.name.replace(/_/g, " ");
         if (tokenSimilarity(skillName.replace(/_/g, " "), existingName) > 0.8) {
-          const metaPath2 = import_path52.default.join(learnedDir, entry.name, "meta.json");
-          if (import_fs50.default.existsSync(metaPath2)) {
+          const metaPath2 = import_path53.default.join(learnedDir, entry.name, "meta.json");
+          if (import_fs51.default.existsSync(metaPath2)) {
             try {
-              const meta = JSON.parse(import_fs50.default.readFileSync(metaPath2, "utf-8"));
+              const meta = JSON.parse(import_fs51.default.readFileSync(metaPath2, "utf-8"));
               meta.successCount = (meta.successCount || 1) + 1;
               meta.lastUsed = Date.now();
               meta.confidence = Math.min(0.99, meta.successCount / (meta.successCount + (meta.failCount || 0) + 1));
-              import_fs50.default.writeFileSync(metaPath2, JSON.stringify(meta, null, 2) + "\n", "utf-8");
+              import_fs51.default.writeFileSync(metaPath2, JSON.stringify(meta, null, 2) + "\n", "utf-8");
             } catch {
             }
           }
@@ -402662,22 +403094,22 @@ async function writeSkillFromTask(args) {
         }
       }
     }
-    const skillDir = import_path52.default.join(learnedDir, skillName);
-    if (import_fs50.default.existsSync(skillDir)) {
-      const metaPath2 = import_path52.default.join(skillDir, "meta.json");
-      if (import_fs50.default.existsSync(metaPath2)) {
+    const skillDir = import_path53.default.join(learnedDir, skillName);
+    if (import_fs51.default.existsSync(skillDir)) {
+      const metaPath2 = import_path53.default.join(skillDir, "meta.json");
+      if (import_fs51.default.existsSync(metaPath2)) {
         try {
-          const meta = JSON.parse(import_fs50.default.readFileSync(metaPath2, "utf-8"));
+          const meta = JSON.parse(import_fs51.default.readFileSync(metaPath2, "utf-8"));
           meta.successCount = (meta.successCount || 1) + 1;
           meta.lastUsed = Date.now();
           meta.confidence = Math.min(0.99, meta.successCount / (meta.successCount + (meta.failCount || 0) + 1));
-          import_fs50.default.writeFileSync(metaPath2, JSON.stringify(meta, null, 2) + "\n", "utf-8");
+          import_fs51.default.writeFileSync(metaPath2, JSON.stringify(meta, null, 2) + "\n", "utf-8");
         } catch {
         }
       }
       return null;
     }
-    import_fs50.default.mkdirSync(skillDir, { recursive: true });
+    import_fs51.default.mkdirSync(skillDir, { recursive: true });
     const title = toTitleCase(skillName);
     const descSnippet = userMessage.slice(0, 100).replace(/\n/g, " ");
     const toolList = toolsUsed.join(", ");
@@ -402733,9 +403165,9 @@ async function writeSkillFromTask(args) {
       tags: inferTags(toolsUsed, userMessage),
       created: (/* @__PURE__ */ new Date()).toISOString()
     };
-    import_fs50.default.writeFileSync(import_path52.default.join(skillDir, "SKILL.md"), skillMd, "utf-8");
-    import_fs50.default.writeFileSync(import_path52.default.join(skillDir, "meta.json"), JSON.stringify(metaJson, null, 2) + "\n", "utf-8");
-    import_fs50.default.writeFileSync(import_path52.default.join(skillDir, "skill.json"), JSON.stringify(taskSkillJson, null, 2) + "\n", "utf-8");
+    import_fs51.default.writeFileSync(import_path53.default.join(skillDir, "SKILL.md"), skillMd, "utf-8");
+    import_fs51.default.writeFileSync(import_path53.default.join(skillDir, "meta.json"), JSON.stringify(metaJson, null, 2) + "\n", "utf-8");
+    import_fs51.default.writeFileSync(import_path53.default.join(skillDir, "skill.json"), JSON.stringify(taskSkillJson, null, 2) + "\n", "utf-8");
     console.log(`[SkillWriter] Wrote skill "${skillName}" \u2192 ${skillDir}`);
     return { skillName, path: skillDir };
   } catch (err) {
@@ -402745,22 +403177,22 @@ async function writeSkillFromTask(args) {
 }
 function listPending() {
   const cwd = process.cwd();
-  const pendDir = import_path52.default.join(cwd, "skills", "learned", "pending");
-  if (!import_fs50.default.existsSync(pendDir)) return [];
-  return import_fs50.default.readdirSync(pendDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => {
+  const pendDir = import_path53.default.join(cwd, "skills", "learned", "pending");
+  if (!import_fs51.default.existsSync(pendDir)) return [];
+  return import_fs51.default.readdirSync(pendDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => {
     try {
-      const meta = JSON.parse(import_fs50.default.readFileSync(import_path52.default.join(pendDir, e.name, "meta.json"), "utf-8"));
+      const meta = JSON.parse(import_fs51.default.readFileSync(import_path53.default.join(pendDir, e.name, "meta.json"), "utf-8"));
       return { id: e.name, name: meta.name || e.name, description: meta.description || "", source: meta.source || "", createdAt: meta.createdAt || "" };
     } catch {
       return { id: e.name, name: e.name, description: "", source: "unknown", createdAt: "" };
     }
   });
 }
-var import_fs50, import_path52, STOP_WORDS2;
+var import_fs51, import_path53, STOP_WORDS2;
 var init_skillWriter = __esm({
   "core/skillWriter.ts"() {
-    import_fs50 = __toESM(require("fs"));
-    import_path52 = __toESM(require("path"));
+    import_fs51 = __toESM(require("fs"));
+    import_path53 = __toESM(require("path"));
     STOP_WORDS2 = /* @__PURE__ */ new Set([
       "a",
       "an",
@@ -1048654,12 +1049086,12 @@ init_contextHandoff();
 // core/voiceInput.ts
 var import_child_process14 = require("child_process");
 var import_util11 = require("util");
-var import_fs44 = __toESM(require("fs"));
-var import_path46 = __toESM(require("path"));
+var import_fs45 = __toESM(require("fs"));
+var import_path47 = __toESM(require("path"));
 var execAsync9 = (0, import_util11.promisify)(import_child_process14.exec);
-var WORKSPACE5 = import_path46.default.join(process.cwd(), "workspace");
+var WORKSPACE5 = import_path47.default.join(process.cwd(), "workspace");
 function ensureWorkspace4() {
-  if (!import_fs44.default.existsSync(WORKSPACE5)) import_fs44.default.mkdirSync(WORKSPACE5, { recursive: true });
+  if (!import_fs45.default.existsSync(WORKSPACE5)) import_fs45.default.mkdirSync(WORKSPACE5, { recursive: true });
 }
 async function checkVoiceAvailable() {
   try {
@@ -1048682,8 +1049114,8 @@ segments, info = model.transcribe("${normalizedPath}", beam_size=5)
 text = " ".join([segment.text for segment in segments])
 print(text.strip())
 `.trim();
-  const tmpScript = import_path46.default.join(WORKSPACE5, `whisper_${Date.now()}.py`);
-  import_fs44.default.writeFileSync(tmpScript, pythonScript);
+  const tmpScript = import_path47.default.join(WORKSPACE5, `whisper_${Date.now()}.py`);
+  import_fs45.default.writeFileSync(tmpScript, pythonScript);
   try {
     const { stdout } = await execAsync9(`python "${tmpScript}"`, { timeout: 3e4 });
     return stdout.trim();
@@ -1048691,14 +1049123,14 @@ print(text.strip())
     throw new Error(`Transcription failed: ${e.message}`);
   } finally {
     try {
-      import_fs44.default.unlinkSync(tmpScript);
+      import_fs45.default.unlinkSync(tmpScript);
     } catch {
     }
   }
 }
 async function recordAudio2(durationMs = 5e3) {
   ensureWorkspace4();
-  const outputPath = import_path46.default.join(WORKSPACE5, `recording_${Date.now()}.wav`);
+  const outputPath = import_path47.default.join(WORKSPACE5, `recording_${Date.now()}.wav`);
   const outputPathFwd = outputPath.replace(/\\/g, "\\\\");
   const psScript = `
 Add-Type -TypeDefinition @"
@@ -1048729,8 +1049161,8 @@ public class AudioRecorder {
 [AudioRecorder]::Record("${outputPathFwd}", ${durationMs})
 Write-Output "${outputPath}"
 `.trim();
-  const psFile2 = import_path46.default.join(WORKSPACE5, `record_${Date.now()}.ps1`);
-  import_fs44.default.writeFileSync(psFile2, psScript);
+  const psFile2 = import_path47.default.join(WORKSPACE5, `record_${Date.now()}.ps1`);
+  import_fs45.default.writeFileSync(psFile2, psScript);
   try {
     await execAsync9(
       `powershell.exe -ExecutionPolicy Bypass -File "${psFile2}"`,
@@ -1048741,7 +1049173,7 @@ Write-Output "${outputPath}"
     throw new Error(`Recording failed: ${e.message}`);
   } finally {
     try {
-      import_fs44.default.unlinkSync(psFile2);
+      import_fs45.default.unlinkSync(psFile2);
     } catch {
     }
   }
@@ -1048750,13 +1049182,13 @@ Write-Output "${outputPath}"
 // core/voiceOutput.ts
 var import_child_process15 = require("child_process");
 var import_util12 = require("util");
-var import_fs45 = __toESM(require("fs"));
-var import_path47 = __toESM(require("path"));
+var import_fs46 = __toESM(require("fs"));
+var import_path48 = __toESM(require("path"));
 var execAsync10 = (0, import_util12.promisify)(import_child_process15.exec);
-var WORKSPACE6 = import_path47.default.join(process.cwd(), "workspace");
+var WORKSPACE6 = import_path48.default.join(process.cwd(), "workspace");
 var DEFAULT_VOICE2 = "en-US-AriaNeural";
 function ensureWorkspace5() {
-  if (!import_fs45.default.existsSync(WORKSPACE6)) import_fs45.default.mkdirSync(WORKSPACE6, { recursive: true });
+  if (!import_fs46.default.existsSync(WORKSPACE6)) import_fs46.default.mkdirSync(WORKSPACE6, { recursive: true });
 }
 async function checkTTSAvailable() {
   try {
@@ -1048782,7 +1049214,7 @@ function cleanForTTS2(text) {
 }
 async function speakEdgeTTS(text, voice) {
   ensureWorkspace5();
-  const audioPath = import_path47.default.join(WORKSPACE6, `tts_${Date.now()}.mp3`);
+  const audioPath = import_path48.default.join(WORKSPACE6, `tts_${Date.now()}.mp3`);
   const audioFwd = audioPath.replace(/\\/g, "/");
   const escapedText = text.replace(/"/g, '\\"').replace(/'/g, "\\'");
   const scriptContent = `
@@ -1048794,11 +1049226,11 @@ async def main():
     await communicate.save("${audioFwd}")
 asyncio.run(main())
 `.trim();
-  const tmpScript = import_path47.default.join(WORKSPACE6, `tts_gen_${Date.now()}.py`);
-  import_fs45.default.writeFileSync(tmpScript, scriptContent);
+  const tmpScript = import_path48.default.join(WORKSPACE6, `tts_gen_${Date.now()}.py`);
+  import_fs46.default.writeFileSync(tmpScript, scriptContent);
   try {
     await execAsync10(`python "${tmpScript}"`, { timeout: 15e3 });
-    if (!import_fs45.default.existsSync(audioPath)) return false;
+    if (!import_fs46.default.existsSync(audioPath)) return false;
     execAsync10(
       `powershell -Command "Add-Type -AssemblyName presentationCore; $mp = New-Object System.Windows.Media.MediaPlayer; $mp.Open([uri]'${audioPath.replace(/\\/g, "\\\\")}'); $mp.Play(); Start-Sleep -Seconds 6; $mp.Stop(); $mp.Close()"`,
       { timeout: 15e3 }
@@ -1048808,7 +1049240,7 @@ asyncio.run(main())
     });
     setTimeout(() => {
       try {
-        import_fs45.default.unlinkSync(audioPath);
+        import_fs46.default.unlinkSync(audioPath);
       } catch {
       }
     }, 12e3);
@@ -1048817,7 +1049249,7 @@ asyncio.run(main())
     return false;
   } finally {
     try {
-      import_fs45.default.unlinkSync(tmpScript);
+      import_fs46.default.unlinkSync(tmpScript);
     } catch {
     }
   }
@@ -1048847,13 +1049279,13 @@ init_planTool();
 init_taskState();
 
 // core/taskQueue.ts
-var import_fs46 = require("fs");
-var import_path48 = require("path");
+var import_fs47 = require("fs");
+var import_path49 = require("path");
 var TaskQueue = class {
   constructor(workspaceDir, chatEndpoint) {
     this.queue = [];
     this.isProcessing = false;
-    this.savePath = (0, import_path48.join)(workspaceDir, "task_queue.json");
+    this.savePath = (0, import_path49.join)(workspaceDir, "task_queue.json");
     this.chatEndpoint = chatEndpoint;
     this.load();
     for (const task of this.queue) {
@@ -1048930,8 +1049362,8 @@ var TaskQueue = class {
   // ── Persistence ───────────────────────────────────────────
   load() {
     try {
-      if ((0, import_fs46.existsSync)(this.savePath)) {
-        this.queue = JSON.parse((0, import_fs46.readFileSync)(this.savePath, "utf8"));
+      if ((0, import_fs47.existsSync)(this.savePath)) {
+        this.queue = JSON.parse((0, import_fs47.readFileSync)(this.savePath, "utf8"));
       }
     } catch {
       this.queue = [];
@@ -1048939,32 +1049371,32 @@ var TaskQueue = class {
   }
   save() {
     try {
-      (0, import_fs46.mkdirSync)((0, import_path48.dirname)(this.savePath), { recursive: true });
-      (0, import_fs46.writeFileSync)(this.savePath, JSON.stringify(this.queue, null, 2));
+      (0, import_fs47.mkdirSync)((0, import_path49.dirname)(this.savePath), { recursive: true });
+      (0, import_fs47.writeFileSync)(this.savePath, JSON.stringify(this.queue, null, 2));
     } catch {
     }
   }
 };
 var taskQueue = new TaskQueue(
-  (0, import_path48.join)(process.cwd(), "workspace"),
+  (0, import_path49.join)(process.cwd(), "workspace"),
   "http://localhost:4200/api/chat"
 );
 
 // core/taskRecovery.ts
-var import_path49 = __toESM(require("path"));
-var import_fs47 = __toESM(require("fs"));
-var TASKS_DIR2 = import_path49.default.join(process.cwd(), "workspace", "tasks");
+var import_path50 = __toESM(require("path"));
+var import_fs48 = __toESM(require("fs"));
+var TASKS_DIR2 = import_path50.default.join(process.cwd(), "workspace", "tasks");
 var MAX_TASK_AGE_MS = 2 * 60 * 60 * 1e3;
 async function recoverTasks() {
-  if (!import_fs47.default.existsSync(TASKS_DIR2)) {
+  if (!import_fs48.default.existsSync(TASKS_DIR2)) {
     console.log("[Recovery] No task directory found \u2014 skipping");
     return;
   }
   let taskDirs;
   try {
-    taskDirs = import_fs47.default.readdirSync(TASKS_DIR2).filter((d) => {
+    taskDirs = import_fs48.default.readdirSync(TASKS_DIR2).filter((d) => {
       try {
-        return import_fs47.default.statSync(import_path49.default.join(TASKS_DIR2, d)).isDirectory();
+        return import_fs48.default.statSync(import_path50.default.join(TASKS_DIR2, d)).isDirectory();
       } catch {
         return false;
       }
@@ -1048977,16 +1049409,16 @@ async function recoverTasks() {
   let cleaned = 0;
   let corrupted = 0;
   for (const taskId of taskDirs) {
-    const statePath = import_path49.default.join(TASKS_DIR2, taskId, "state.json");
-    if (!import_fs47.default.existsSync(statePath)) continue;
+    const statePath = import_path50.default.join(TASKS_DIR2, taskId, "state.json");
+    if (!import_fs48.default.existsSync(statePath)) continue;
     let state;
     try {
-      state = JSON.parse(import_fs47.default.readFileSync(statePath, "utf-8"));
+      state = JSON.parse(import_fs48.default.readFileSync(statePath, "utf-8"));
     } catch {
       corrupted++;
       try {
         const tmp = statePath + ".tmp";
-        import_fs47.default.writeFileSync(tmp, JSON.stringify({
+        import_fs48.default.writeFileSync(tmp, JSON.stringify({
           id: taskId,
           status: "failed",
           error: "Corrupt state file \u2014 overwritten on startup",
@@ -1048994,11 +1049426,11 @@ async function recoverTasks() {
           updatedAt: Date.now()
         }, null, 2));
         try {
-          import_fs47.default.renameSync(tmp, statePath);
+          import_fs48.default.renameSync(tmp, statePath);
         } catch {
-          import_fs47.default.writeFileSync(statePath, import_fs47.default.readFileSync(tmp, "utf-8"));
+          import_fs48.default.writeFileSync(statePath, import_fs48.default.readFileSync(tmp, "utf-8"));
           try {
-            import_fs47.default.unlinkSync(tmp);
+            import_fs48.default.unlinkSync(tmp);
           } catch {
           }
         }
@@ -1049016,13 +1049448,13 @@ async function recoverTasks() {
       cleaned++;
       try {
         const tmp = statePath + ".tmp";
-        import_fs47.default.writeFileSync(tmp, JSON.stringify(state, null, 2));
+        import_fs48.default.writeFileSync(tmp, JSON.stringify(state, null, 2));
         try {
-          import_fs47.default.renameSync(tmp, statePath);
+          import_fs48.default.renameSync(tmp, statePath);
         } catch {
-          import_fs47.default.writeFileSync(statePath, JSON.stringify(state, null, 2));
+          import_fs48.default.writeFileSync(statePath, JSON.stringify(state, null, 2));
           try {
-            import_fs47.default.unlinkSync(tmp);
+            import_fs48.default.unlinkSync(tmp);
           } catch {
           }
         }
@@ -1049055,164 +1049487,10 @@ async function recoverTasks() {
 
 // api/server.ts
 init_skillLoader();
-
-// core/memoryIds.ts
-var fs53 = __toESM(require("fs"));
-var path55 = __toESM(require("path"));
-var MEM_DIR = path55.join(process.cwd(), "workspace", "memory");
-var SEQUENCE_FILE = path55.join(MEM_DIR, "sequence.json");
-var RECORDS_FILE = path55.join(MEM_DIR, "records.jsonl");
-function _ensureDir() {
-  fs53.mkdirSync(MEM_DIR, { recursive: true });
-}
-function _readSeq() {
-  try {
-    if (!fs53.existsSync(SEQUENCE_FILE)) return 0;
-    const d = JSON.parse(fs53.readFileSync(SEQUENCE_FILE, "utf-8"));
-    return typeof d.next === "number" ? d.next : 0;
-  } catch {
-    return 0;
-  }
-}
-function _writeSeq(n) {
-  _ensureDir();
-  fs53.writeFileSync(SEQUENCE_FILE, JSON.stringify({ next: n }), "utf-8");
-}
-function nextId() {
-  const n = _readSeq();
-  _writeSeq(n + 1);
-  return `mem_${String(n + 1).padStart(6, "0")}`;
-}
-function appendRecord(record2) {
-  _ensureDir();
-  fs53.appendFileSync(RECORDS_FILE, JSON.stringify(record2) + "\n", "utf-8");
-}
-function loadAllRecords() {
-  try {
-    if (!fs53.existsSync(RECORDS_FILE)) return [];
-    return fs53.readFileSync(RECORDS_FILE, "utf-8").split("\n").filter((l2) => l2.trim()).map((l2) => {
-      try {
-        return JSON.parse(l2);
-      } catch {
-        return null;
-      }
-    }).filter((r) => r !== null);
-  } catch {
-    return [];
-  }
-}
-function loadRecordById(id) {
-  const all3 = loadAllRecords();
-  return all3.find((r) => r.id === id) ?? null;
-}
-function removeRecords(predicate) {
-  const all3 = loadAllRecords();
-  const kept = all3.filter((r) => !predicate(r));
-  const removed = all3.length - kept.length;
-  if (removed > 0) {
-    _ensureDir();
-    fs53.writeFileSync(
-      RECORDS_FILE,
-      kept.map((r) => JSON.stringify(r)).join("\n") + (kept.length ? "\n" : ""),
-      "utf-8"
-    );
-  }
-  return removed;
-}
-function assignId(partial2) {
-  const record2 = {
-    id: partial2.id ?? nextId(),
-    timestamp: partial2.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
-    type: partial2.type ?? "observation",
-    content: partial2.content ?? "",
-    summary: partial2.summary ?? _autoSummary(partial2.content ?? ""),
-    sessionId: partial2.sessionId,
-    tags: partial2.tags,
-    entityRefs: partial2.entityRefs
-  };
-  appendRecord(record2);
-  return record2;
-}
-function _autoSummary(content) {
-  const first = content.split("\n").find((l2) => l2.trim()) ?? content;
-  return first.slice(0, 100).trim();
-}
-function runMigrationIfNeeded() {
-  if (fs53.existsSync(RECORDS_FILE)) return 0;
-  _ensureDir();
-  const records = [];
-  try {
-    const raw = fs53.readFileSync(path55.join(MEM_DIR, "memory.json"), "utf-8");
-    const parsed = JSON.parse(raw);
-    const items = Array.isArray(parsed) ? parsed : parsed.value ?? [];
-    for (const item of items) {
-      const v = item.value ?? {};
-      const content = [
-        v.goal ? `Goal: ${v.goal}` : "",
-        v.result ? `Result: ${String(v.result).slice(0, 800)}` : "",
-        v.role ? `Role: ${v.role}` : ""
-      ].filter(Boolean).join("\n");
-      if (!content) continue;
-      records.push({
-        timestamp: item.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-        type: item.tags?.includes("task") ? "interaction" : "observation",
-        content,
-        summary: _autoSummary(v.goal ?? v.result ?? content),
-        tags: item.tags ?? []
-      });
-    }
-  } catch {
-  }
-  try {
-    const raw = fs53.readFileSync(
-      path55.join(process.cwd(), "workspace", "conversation-memory.json"),
-      "utf-8"
-    );
-    const parsed = JSON.parse(raw);
-    const msgs = parsed.messages ?? [];
-    for (const msg of msgs) {
-      if (msg.role !== "assistant") continue;
-      const content = String(msg.content ?? "").trim();
-      if (content.length < 20) continue;
-      records.push({
-        timestamp: msg.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
-        type: "interaction",
-        content: content.slice(0, 1e3),
-        summary: _autoSummary(content),
-        sessionId: msg.sessionId,
-        tags: ["conversation"]
-      });
-    }
-  } catch {
-  }
-  try {
-    const raw = fs53.readFileSync(path55.join(MEM_DIR, "MEMORY_INDEX.md"), "utf-8");
-    const lines = raw.split("\n").filter((l2) => l2.startsWith("- "));
-    for (const line of lines) {
-      const cleaned = line.replace(/^-\s*/, "").trim();
-      if (cleaned.length < 10) continue;
-      records.push({
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        type: "fact",
-        content: cleaned,
-        summary: cleaned.slice(0, 100),
-        tags: ["index"]
-      });
-    }
-  } catch {
-  }
-  records.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
-  let count = 0;
-  for (const rec of records) {
-    const id = nextId();
-    const record2 = { id, ...rec };
-    appendRecord(record2);
-    count++;
-  }
-  return count;
-}
+init_memoryIds();
 
 // core/memoryQuery.ts
+init_memoryIds();
 var _sessionCitations = /* @__PURE__ */ new Map();
 function trackCitation(id, summary) {
   const c = _sessionCitations.get(id);
@@ -1049310,11 +1049588,11 @@ init_knowledgeBase();
 init_youtubeTranscript();
 
 // core/importers.ts
-var import_fs48 = __toESM(require("fs"));
-var import_path50 = __toESM(require("path"));
+var import_fs49 = __toESM(require("fs"));
+var import_path51 = __toESM(require("path"));
 init_knowledgeBase();
 var WORKSPACE_ROOT2 = process.env.AIDEN_USER_DATA || process.cwd();
-var MEMORY_DIR4 = import_path50.default.join(WORKSPACE_ROOT2, "workspace", "memory");
+var MEMORY_DIR4 = import_path51.default.join(WORKSPACE_ROOT2, "workspace", "memory");
 async function importChatGPT(filePath) {
   const result = {
     source: "chatgpt",
@@ -1049323,7 +1049601,7 @@ async function importChatGPT(filePath) {
     errors: []
   };
   try {
-    const raw = import_fs48.default.readFileSync(filePath, "utf8");
+    const raw = import_fs49.default.readFileSync(filePath, "utf8");
     const conversations = JSON.parse(raw);
     if (!Array.isArray(conversations)) {
       result.errors.push("Invalid format: expected array of conversations");
@@ -1049373,9 +1049651,9 @@ async function importChatGPT(filePath) {
 function findMdFiles(dir) {
   const files = [];
   try {
-    const entries = import_fs48.default.readdirSync(dir, { withFileTypes: true });
+    const entries = import_fs49.default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = import_path50.default.join(dir, entry.name);
+      const fullPath = import_path51.default.join(dir, entry.name);
       if (entry.isDirectory() && !entry.name.startsWith(".")) {
         files.push(...findMdFiles(fullPath));
       } else if (entry.name.endsWith(".md")) {
@@ -1049393,16 +1049671,16 @@ async function importOpenClaw(directoryPath) {
     memoriesExtracted: 0,
     errors: []
   };
-  if (!import_fs48.default.existsSync(directoryPath)) {
+  if (!import_fs49.default.existsSync(directoryPath)) {
     result.errors.push(`Directory not found: ${directoryPath}`);
     return result;
   }
   const mdFiles = findMdFiles(directoryPath);
   for (const file of mdFiles) {
     try {
-      const content = import_fs48.default.readFileSync(file, "utf8");
+      const content = import_fs49.default.readFileSync(file, "utf8");
       if (content.trim().length < 50) continue;
-      const basename5 = import_path50.default.basename(file, ".md");
+      const basename5 = import_path51.default.basename(file, ".md");
       const lower = file.toLowerCase();
       const isMemory = lower.includes("memory");
       const isLesson = lower.includes("lesson");
@@ -1049423,11 +1049701,11 @@ async function importOpenClaw(directoryPath) {
       }
       if (isMemory || isLesson) {
         try {
-          import_fs48.default.mkdirSync(MEMORY_DIR4, { recursive: true });
+          import_fs49.default.mkdirSync(MEMORY_DIR4, { recursive: true });
           const destName = `imported_${basename5.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 60)}.md`;
-          const destPath = import_path50.default.join(MEMORY_DIR4, destName);
-          if (!import_fs48.default.existsSync(destPath)) {
-            import_fs48.default.writeFileSync(
+          const destPath = import_path51.default.join(MEMORY_DIR4, destName);
+          if (!import_fs49.default.existsSync(destPath)) {
+            import_fs49.default.writeFileSync(
               destPath,
               `<!-- source: openclaw_import | confidence: 0.7 -->
 ${content}`,
@@ -1049440,7 +1049718,7 @@ ${content}`,
         }
       }
     } catch (err) {
-      result.errors.push(`Failed: ${import_path50.default.basename(file)}`);
+      result.errors.push(`Failed: ${import_path51.default.basename(file)}`);
     }
   }
   console.log(
@@ -1049524,9 +1049802,9 @@ init_morningBriefing();
 init_memoryRecall();
 
 // core/lessonsBrowser.ts
-var import_fs49 = __toESM(require("fs"));
-var import_path51 = __toESM(require("path"));
-var LESSONS_PATH2 = import_path51.default.join(process.cwd(), "workspace", "LESSONS.md");
+var import_fs50 = __toESM(require("fs"));
+var import_path52 = __toESM(require("path"));
+var LESSONS_PATH3 = import_path52.default.join(process.cwd(), "workspace", "LESSONS.md");
 var CATEGORY_RULES = [
   [/web_search|search|query|url/i, "web"],
   [/shell_exec|run_python|command|bash/i, "shell"],
@@ -1049546,7 +1049824,7 @@ function inferCategory(text) {
 function parseLessons() {
   let raw = "";
   try {
-    raw = import_fs49.default.readFileSync(LESSONS_PATH2, "utf-8");
+    raw = import_fs50.default.readFileSync(LESSONS_PATH3, "utf-8");
   } catch {
     return [];
   }
@@ -1049585,12 +1049863,12 @@ function appendLesson2(text) {
   const entry = `${id}. [${date3}] ${text}
 `;
   try {
-    if (!import_fs49.default.existsSync(LESSONS_PATH2)) {
+    if (!import_fs50.default.existsSync(LESSONS_PATH3)) {
       const header = "# LESSONS.md \u2014 Permanent Failure Rules\n# Auto-appended after task failures.\n\n## Rules\n\n";
-      import_fs49.default.mkdirSync(import_path51.default.dirname(LESSONS_PATH2), { recursive: true });
-      import_fs49.default.writeFileSync(LESSONS_PATH2, header + entry, "utf-8");
+      import_fs50.default.mkdirSync(import_path52.default.dirname(LESSONS_PATH3), { recursive: true });
+      import_fs50.default.writeFileSync(LESSONS_PATH3, header + entry, "utf-8");
     } else {
-      import_fs49.default.appendFileSync(LESSONS_PATH2, entry, "utf-8");
+      import_fs50.default.appendFileSync(LESSONS_PATH3, entry, "utf-8");
     }
   } catch {
   }
@@ -1050148,13 +1050426,13 @@ function getCatalog() {
 init_permissionSystem();
 
 // core/aidenIdentity.ts
-var import_fs51 = __toESM(require("fs"));
-var import_path53 = __toESM(require("path"));
+var import_fs52 = __toESM(require("fs"));
+var import_path54 = __toESM(require("path"));
 init_skillTeacher();
 init_eventBus();
-var IDENTITY_PATH = import_path53.default.join(process.cwd(), "workspace", "identity.json");
-var AUDIT_PATH2 = import_path53.default.join(process.cwd(), "workspace", "audit", "audit.jsonl");
-var SESSIONS_DIR4 = import_path53.default.join(process.cwd(), "workspace", "sessions");
+var IDENTITY_PATH = import_path54.default.join(process.cwd(), "workspace", "identity.json");
+var AUDIT_PATH2 = import_path54.default.join(process.cwd(), "workspace", "audit", "audit.jsonl");
+var SESSIONS_DIR4 = import_path54.default.join(process.cwd(), "workspace", "sessions");
 var LEVEL_THRESHOLDS = [0, 10, 50, 200, 500];
 var TITLES = ["Apprentice", "Assistant", "Specialist", "Expert", "Architect"];
 function computeLevel(xp) {
@@ -1050177,8 +1050455,8 @@ function computeProgress(xp, level) {
 }
 function computeXP() {
   try {
-    if (!import_fs51.default.existsSync(AUDIT_PATH2)) return 0;
-    return import_fs51.default.readFileSync(AUDIT_PATH2, "utf-8").trim().split("\n").filter(Boolean).map((l2) => {
+    if (!import_fs52.default.existsSync(AUDIT_PATH2)) return 0;
+    return import_fs52.default.readFileSync(AUDIT_PATH2, "utf-8").trim().split("\n").filter(Boolean).map((l2) => {
       try {
         return JSON.parse(l2);
       } catch {
@@ -1050191,8 +1050469,8 @@ function computeXP() {
 }
 function computeTopStrength() {
   try {
-    if (!import_fs51.default.existsSync(AUDIT_PATH2)) return "Research";
-    const entries = import_fs51.default.readFileSync(AUDIT_PATH2, "utf-8").trim().split("\n").filter(Boolean).map((l2) => {
+    if (!import_fs52.default.existsSync(AUDIT_PATH2)) return "Research";
+    const entries = import_fs52.default.readFileSync(AUDIT_PATH2, "utf-8").trim().split("\n").filter(Boolean).map((l2) => {
       try {
         return JSON.parse(l2);
       } catch {
@@ -1050219,20 +1050497,20 @@ function computeTopStrength() {
 }
 function computeStreakDays() {
   try {
-    if (!import_fs51.default.existsSync(SESSIONS_DIR4)) return 0;
+    if (!import_fs52.default.existsSync(SESSIONS_DIR4)) return 0;
     const sessionDates = /* @__PURE__ */ new Set();
-    for (const f of import_fs51.default.readdirSync(SESSIONS_DIR4)) {
+    for (const f of import_fs52.default.readdirSync(SESSIONS_DIR4)) {
       if (!f.endsWith(".md")) continue;
       try {
-        const mtime = import_fs51.default.statSync(import_path53.default.join(SESSIONS_DIR4, f)).mtime;
+        const mtime = import_fs52.default.statSync(import_path54.default.join(SESSIONS_DIR4, f)).mtime;
         sessionDates.add(mtime.toISOString().slice(0, 10));
       } catch {
       }
     }
     if (sessionDates.size === 0) return 0;
     const auditDates = /* @__PURE__ */ new Set();
-    if (import_fs51.default.existsSync(AUDIT_PATH2)) {
-      for (const line of import_fs51.default.readFileSync(AUDIT_PATH2, "utf-8").trim().split("\n").filter(Boolean)) {
+    if (import_fs52.default.existsSync(AUDIT_PATH2)) {
+      for (const line of import_fs52.default.readFileSync(AUDIT_PATH2, "utf-8").trim().split("\n").filter(Boolean)) {
         try {
           const e = JSON.parse(line);
           if (e.ts) auditDates.add(new Date(e.ts).toISOString().slice(0, 10));
@@ -1050282,8 +1050560,8 @@ function computeIdentity() {
 function refreshIdentity() {
   const identity = computeIdentity();
   try {
-    import_fs51.default.mkdirSync(import_path53.default.dirname(IDENTITY_PATH), { recursive: true });
-    import_fs51.default.writeFileSync(IDENTITY_PATH, JSON.stringify(identity, null, 2));
+    import_fs52.default.mkdirSync(import_path54.default.dirname(IDENTITY_PATH), { recursive: true });
+    import_fs52.default.writeFileSync(IDENTITY_PATH, JSON.stringify(identity, null, 2));
   } catch (e) {
     console.error("[AidenIdentity] Write failed:", e.message);
   }
@@ -1050295,8 +1050573,8 @@ function refreshIdentity() {
 }
 function loadIdentity() {
   try {
-    if (!import_fs51.default.existsSync(IDENTITY_PATH)) return null;
-    return JSON.parse(import_fs51.default.readFileSync(IDENTITY_PATH, "utf-8"));
+    if (!import_fs52.default.existsSync(IDENTITY_PATH)) return null;
+    return JSON.parse(import_fs52.default.readFileSync(IDENTITY_PATH, "utf-8"));
   } catch {
     return null;
   }
@@ -1050305,7 +1050583,7 @@ function getIdentity() {
   return loadIdentity() ?? refreshIdentity();
 }
 try {
-  import_fs51.default.mkdirSync(import_path53.default.dirname(IDENTITY_PATH), { recursive: true });
+  import_fs52.default.mkdirSync(import_path54.default.dirname(IDENTITY_PATH), { recursive: true });
 } catch {
 }
 
@@ -1050497,8 +1050775,8 @@ function registerTelegramCallbacks(bot) {
 }
 
 // core/memoryDistiller.ts
-var import_fs52 = __toESM(require("fs"));
-var import_path54 = __toESM(require("path"));
+var import_fs53 = __toESM(require("fs"));
+var import_path55 = __toESM(require("path"));
 init_conversationMemory();
 init_semanticMemory();
 init_agentLoop();
@@ -1050518,7 +1050796,7 @@ No headings, no explanations, no blank lines between facts.
 Facts must be self-contained (understandable without the conversation).
 Maximum 15 facts. Minimum 5 facts if the conversation has meaningful content.`;
 var MAX_TRANSCRIPT_CHARS = 32e3;
-var DISTILL_MARKER_PATH = import_path54.default.join(process.cwd(), "workspace", "distilled_sessions.json");
+var DISTILL_MARKER_PATH = import_path55.default.join(process.cwd(), "workspace", "distilled_sessions.json");
 async function distillSession(sessionId, timeoutMs = 15e3) {
   try {
     conversationMemory.setSession(sessionId);
@@ -1050581,8 +1050859,8 @@ async function distillAllActiveSessions(timeoutMs = 8e3) {
 }
 function loadDistilledSet() {
   try {
-    if (import_fs52.default.existsSync(DISTILL_MARKER_PATH)) {
-      return new Set(JSON.parse(import_fs52.default.readFileSync(DISTILL_MARKER_PATH, "utf-8")));
+    if (import_fs53.default.existsSync(DISTILL_MARKER_PATH)) {
+      return new Set(JSON.parse(import_fs53.default.readFileSync(DISTILL_MARKER_PATH, "utf-8")));
     }
   } catch {
   }
@@ -1050595,15 +1050873,15 @@ function markDistilled(sessionId) {
   try {
     const set2 = loadDistilledSet();
     set2.add(sessionId);
-    import_fs52.default.mkdirSync(import_path54.default.dirname(DISTILL_MARKER_PATH), { recursive: true });
-    import_fs52.default.writeFileSync(DISTILL_MARKER_PATH, JSON.stringify([...set2], null, 2) + "\n", "utf-8");
+    import_fs53.default.mkdirSync(import_path55.default.dirname(DISTILL_MARKER_PATH), { recursive: true });
+    import_fs53.default.writeFileSync(DISTILL_MARKER_PATH, JSON.stringify([...set2], null, 2) + "\n", "utf-8");
   } catch {
   }
 }
 
 // core/failureAnalyzer.ts
-var import_fs53 = __toESM(require("fs"));
-var import_path55 = __toESM(require("path"));
+var import_fs54 = __toESM(require("fs"));
+var import_path56 = __toESM(require("path"));
 var FAILURE_KEYWORDS = [
   "that's wrong",
   "thats wrong",
@@ -1050686,10 +1050964,10 @@ function _degradeSkill(skillName, rootCause) {
   const cwd = process.cwd();
   const folders = ["learned", "approved", "installed"];
   for (const folder of folders) {
-    const metaPath2 = import_path55.default.join(cwd, "workspace", "skills", folder, skillName, "meta.json");
-    if (!import_fs53.default.existsSync(metaPath2)) continue;
+    const metaPath2 = import_path56.default.join(cwd, "workspace", "skills", folder, skillName, "meta.json");
+    if (!import_fs54.default.existsSync(metaPath2)) continue;
     try {
-      const meta = JSON.parse(import_fs53.default.readFileSync(metaPath2, "utf-8"));
+      const meta = JSON.parse(import_fs54.default.readFileSync(metaPath2, "utf-8"));
       meta.failCount = (meta.failCount ?? 0) + 1;
       meta.lastFailureReason = rootCause;
       meta.confidence = Math.max(0.1, (meta.confidence ?? 1) - 0.15);
@@ -1050697,7 +1050975,7 @@ function _degradeSkill(skillName, rootCause) {
         meta.deprecated = true;
         console.warn(`[failureAnalyzer] skill "${skillName}" auto-deprecated after ${meta.failCount} failures`);
       }
-      import_fs53.default.writeFileSync(metaPath2, JSON.stringify(meta, null, 2) + "\n", "utf-8");
+      import_fs54.default.writeFileSync(metaPath2, JSON.stringify(meta, null, 2) + "\n", "utf-8");
       console.log(`[failureAnalyzer] degraded skill "${skillName}" \u2192 confidence ${meta.confidence.toFixed(2)}, failCount ${meta.failCount}`);
     } catch (e) {
       console.warn(`[failureAnalyzer] could not update meta for "${skillName}":`, e.message);
@@ -1050707,8 +1050985,8 @@ function _degradeSkill(skillName, rootCause) {
 }
 
 // core/sessionRouter.ts
-var import_fs54 = __toESM(require("fs"));
-var import_path56 = __toESM(require("path"));
+var import_fs55 = __toESM(require("fs"));
+var import_path57 = __toESM(require("path"));
 var SessionRouter = class {
   constructor() {
     this.sessions = /* @__PURE__ */ new Map();
@@ -1050749,15 +1051027,15 @@ var SessionRouter = class {
   getHistory(userId) {
     const sessionId = this.userToSession.get(userId);
     if (!sessionId) return [];
-    const sessionFile = import_path56.default.join(
+    const sessionFile = import_path57.default.join(
       process.cwd(),
       "workspace",
       "sessions",
       `${sessionId}.json`
     );
-    if (import_fs54.default.existsSync(sessionFile)) {
+    if (import_fs55.default.existsSync(sessionFile)) {
       try {
-        const data = JSON.parse(import_fs54.default.readFileSync(sessionFile, "utf8"));
+        const data = JSON.parse(import_fs55.default.readFileSync(sessionFile, "utf8"));
         return data.messages || [];
       } catch {
       }
@@ -1050883,8 +1051161,8 @@ var Gateway = class {
 var gateway = new Gateway();
 
 // core/agentShield.ts
-var import_fs55 = __toESM(require("fs"));
-var import_path57 = __toESM(require("path"));
+var import_fs56 = __toESM(require("fs"));
+var import_path58 = __toESM(require("path"));
 var WORKSPACE_ROOT3 = process.env.AIDEN_USER_DATA || process.cwd();
 var INJECTION_PATTERNS2 = [
   { pattern: /ignore\s+(all\s+)?(previous|above|prior)/i, desc: "Prompt injection: ignore previous instructions" },
@@ -1050924,26 +1051202,26 @@ async function runSecurityScan() {
   let toolsScanned = 0;
   let configsScanned = 0;
   const skillDirs = [
-    import_path57.default.join(WORKSPACE_ROOT3, "skills"),
-    import_path57.default.join(WORKSPACE_ROOT3, "workspace", "skills"),
-    import_path57.default.join(WORKSPACE_ROOT3, "workspace", "skills", "learned"),
-    import_path57.default.join(WORKSPACE_ROOT3, "workspace", "skills", "approved")
+    import_path58.default.join(WORKSPACE_ROOT3, "skills"),
+    import_path58.default.join(WORKSPACE_ROOT3, "workspace", "skills"),
+    import_path58.default.join(WORKSPACE_ROOT3, "workspace", "skills", "learned"),
+    import_path58.default.join(WORKSPACE_ROOT3, "workspace", "skills", "approved")
   ];
   for (const dir of skillDirs) {
-    if (!import_fs55.default.existsSync(dir)) continue;
+    if (!import_fs56.default.existsSync(dir)) continue;
     let entries;
     try {
-      entries = import_fs55.default.readdirSync(dir, { withFileTypes: true });
+      entries = import_fs56.default.readdirSync(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const skillPath = entry.isDirectory() ? import_path57.default.join(dir, entry.name, "SKILL.md") : entry.name.endsWith(".md") ? import_path57.default.join(dir, entry.name) : "";
-      if (!skillPath || !import_fs55.default.existsSync(skillPath)) continue;
+      const skillPath = entry.isDirectory() ? import_path58.default.join(dir, entry.name, "SKILL.md") : entry.name.endsWith(".md") ? import_path58.default.join(dir, entry.name) : "";
+      if (!skillPath || !import_fs56.default.existsSync(skillPath)) continue;
       const relPath = `skills/${entry.name}${entry.isDirectory() ? "/SKILL.md" : ""}`;
       let content;
       try {
-        content = import_fs55.default.readFileSync(skillPath, "utf8");
+        content = import_fs56.default.readFileSync(skillPath, "utf8");
       } catch {
         continue;
       }
@@ -1050980,11 +1051258,11 @@ async function runSecurityScan() {
     }
   }
   configsScanned++;
-  const configPath = import_path57.default.join(WORKSPACE_ROOT3, "config", "devos.config.json");
-  if (import_fs55.default.existsSync(configPath)) {
+  const configPath = import_path58.default.join(WORKSPACE_ROOT3, "config", "devos.config.json");
+  if (import_fs56.default.existsSync(configPath)) {
     let config2 = "";
     try {
-      config2 = import_fs55.default.readFileSync(configPath, "utf8");
+      config2 = import_fs56.default.readFileSync(configPath, "utf8");
     } catch {
     }
     if (config2 && RAW_KEY_PATTERN.test(config2)) {
@@ -1051004,11 +1051282,11 @@ async function runSecurityScan() {
     { name: "LESSONS.md", critical: false }
   ];
   for (const { name, critical } of sensitiveFiles) {
-    const filePath = import_path57.default.join(WORKSPACE_ROOT3, "workspace", name);
-    if (!import_fs55.default.existsSync(filePath)) continue;
+    const filePath = import_path58.default.join(WORKSPACE_ROOT3, "workspace", name);
+    if (!import_fs56.default.existsSync(filePath)) continue;
     let content = "";
     try {
-      content = import_fs55.default.readFileSync(filePath, "utf8");
+      content = import_fs56.default.readFileSync(filePath, "utf8");
     } catch {
       continue;
     }
@@ -1051142,193 +1051420,8 @@ var AsyncTaskManager = class {
 };
 var asyncTasks = new AsyncTaskManager();
 
-// core/slashAsTool.ts
-var import_fs56 = __toESM(require("fs"));
-var import_path58 = __toESM(require("path"));
-var import_os5 = __toESM(require("os"));
-init_toolRegistry();
-init_conversationMemory();
-init_learningMemory();
-init_skillLoader();
-init_costTracker();
-init_goalTracker();
-init_providers();
-var LESSONS_PATH3 = import_path58.default.join(process.cwd(), "workspace", "LESSONS.md");
-function loadLessonsText() {
-  try {
-    if (import_fs56.default.existsSync(LESSONS_PATH3)) return import_fs56.default.readFileSync(LESSONS_PATH3, "utf-8").trim();
-  } catch {
-  }
-  return "";
-}
-async function toolStatus(_2) {
-  const uptimeSec = Math.floor(process.uptime());
-  const ramMB = Math.round(process.memoryUsage().heapUsed / 1024 / 1024);
-  const sessions = conversationMemory.getSessions().length;
-  const lines = [
-    "SYSTEM STATUS",
-    `Uptime       ${Math.floor(uptimeSec / 60)}m ${uptimeSec % 60}s`,
-    `RAM          ${ramMB} MB`,
-    `Sessions     ${sessions}`,
-    `Platform     ${import_os5.default.platform()} ${import_os5.default.arch()}`,
-    `Node         ${process.version}`
-  ];
-  return { success: true, output: lines.join("\n") };
-}
-async function toolAnalytics(_2) {
-  const stats = learningMemory.getStats();
-  const lines = [
-    "LEARNING ANALYTICS",
-    `Total tasks    ${stats.total}`,
-    `Success rate   ${stats.successRate}%`,
-    `Avg duration   ${stats.avgDuration}ms`
-  ];
-  return { success: true, output: lines.join("\n") };
-}
-async function toolSpend(_2) {
-  try {
-    const summary = costTracker.getDailySummary();
-    const byProvider = Object.entries(summary.byProvider || {}).map(([p, c]) => `  ${p}: $${c.toFixed(4)}`).join("\n");
-    const lines = [
-      `SPEND \u2014 ${summary.date}`,
-      `Total   $${summary.totalUSD.toFixed(4)}`,
-      `User    $${summary.userUSD.toFixed(4)}`,
-      `System  $${summary.systemUSD.toFixed(4)}`,
-      byProvider ? `By provider:
-${byProvider}` : ""
-    ].filter(Boolean);
-    return { success: true, output: lines.join("\n") };
-  } catch {
-    return { success: true, output: "Spend data unavailable." };
-  }
-}
-async function toolMemoryShow(_2) {
-  const facts = conversationMemory.getFacts();
-  const history2 = conversationMemory.getRecentHistory();
-  const lines = [
-    "MEMORY FACTS",
-    facts.lastFilesCreated.length ? `Files created : ${facts.lastFilesCreated.join(", ")}` : "",
-    facts.lastSearchQueries.length ? `Last searches : ${facts.lastSearchQueries.join(", ")}` : "",
-    facts.lastToolsUsed.length ? `Last tools    : ${facts.lastToolsUsed.join(", ")}` : "",
-    facts.mentionedEntities.length ? `Topics        : ${facts.mentionedEntities.slice(-10).join(", ")}` : "",
-    "",
-    `Recent exchanges: ${history2.length}`,
-    ...history2.slice(-3).map(
-      (e) => e.userMessage ? `  User: ${e.userMessage.slice(0, 80)}` : ""
-    ).filter(Boolean)
-  ].filter((l2) => l2 !== void 0);
-  return { success: true, output: lines.join("\n") };
-}
-async function toolLessons(_2) {
-  const lessons = loadLessonsText();
-  if (!lessons) return { success: true, output: "No lessons recorded yet." };
-  return { success: true, output: `LESSONS (permanent failure rules):
-${lessons}` };
-}
-async function toolSkillsList(_2) {
-  const skills = skillLoader.loadAll();
-  if (skills.length === 0) return { success: true, output: "No skills loaded." };
-  const lines = [
-    `SKILLS (${skills.length} loaded)`,
-    ...skills.map((s) => `  ${s.name.padEnd(20)} ${s.description || ""}`)
-  ];
-  return { success: true, output: lines.join("\n") };
-}
-async function toolToolsList(_2) {
-  const { TOOLS: TOOLS3 } = await Promise.resolve().then(() => (init_toolRegistry(), toolRegistry_exports));
-  const names = Object.keys(TOOLS3).sort();
-  return { success: true, output: `TOOLS (${names.length}):
-${names.join(", ")}` };
-}
-async function toolWhoami(_2) {
-  const cfg = loadConfig();
-  const userName = cfg.userName || process.env.USERNAME || import_os5.default.userInfo().username || "User";
-  const homeDir = import_os5.default.homedir();
-  const lines = [
-    "USER PROFILE",
-    `Name         ${userName}`,
-    `Home         ${homeDir}`,
-    `Platform     ${import_os5.default.platform()}`
-  ];
-  return { success: true, output: lines.join("\n") };
-}
-async function toolChannelsStatus(_2) {
-  try {
-    const cfg = loadConfig();
-    const apis = cfg?.providers?.apis || [];
-    const lines = [
-      "PROVIDER CHANNELS",
-      ...apis.map((api) => {
-        const key2 = String(api.key || "");
-        const hasKey = key2.startsWith("env:") ? !!(process.env[key2.replace("env:", "")] || "").trim() : key2.trim().length > 0;
-        const status = !api.enabled ? "disabled" : api.rateLimited ? "rate-limited" : hasKey ? "active" : "no key";
-        return `  ${(api.name || api.provider || "").padEnd(20)} ${api.model || ""}  [${status}]`;
-      })
-    ];
-    return { success: true, output: lines.join("\n") };
-  } catch {
-    return { success: true, output: "Provider status unavailable." };
-  }
-}
-async function toolMemoryStore(input) {
-  const fact = String(
-    input?.fact || input?.content || input?.text || input?.preference || input?.value || input?.memory || input?.note || input?.data || input?.information || input?.detail || input?.message || input?.entry || input?.record || (input && typeof input === "object" ? Object.values(input).find((v) => typeof v === "string" && v.trim().length > 0) : "") || ""
-  ).trim();
-  if (!fact) return { success: false, output: 'No fact provided. Pass { fact: "the thing to remember" }' };
-  const record2 = assignId({
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    type: input?.type ?? "fact",
-    content: fact,
-    summary: fact.slice(0, 100),
-    tags: Array.isArray(input?.tags) ? input.tags : []
-  });
-  return { success: true, output: `Stored as ${record2.id}: ${record2.summary}` };
-}
-async function toolMemoryForget(input) {
-  const keyword = String(
-    input?.fact || input?.keyword || input?.content || input?.text || input?.query || input?.topic || input?.subject || (input && typeof input === "object" ? Object.values(input).find((v) => typeof v === "string" && v.trim().length > 0) : "") || ""
-  ).trim().toLowerCase();
-  if (!keyword)
-    return { success: false, output: 'No keyword provided. Pass { fact: "thing to forget" }' };
-  const removed = removeRecords(
-    (r) => r.content.toLowerCase().includes(keyword) || r.summary.toLowerCase().includes(keyword)
-  );
-  if (removed === 0)
-    return { success: true, output: `No memory entries matched "${keyword}".` };
-  return { success: true, output: `Removed ${removed} memory entry(s) matching "${keyword}".` };
-}
-async function toolGoals(_2) {
-  const summary = getActiveGoalsSummary();
-  return { success: true, output: summary ? `ACTIVE GOALS:
-${summary}` : "No active goals." };
-}
-var MIRROR_TOOLS = [
-  { name: "status", description: "Show system status: uptime, RAM, session count", fn: toolStatus },
-  { name: "analytics", description: "Show learning analytics: task count, success rate", fn: toolAnalytics },
-  { name: "spend", description: "Show today's token cost and spend by provider", fn: toolSpend },
-  { name: "memory_show", description: "Show conversation memory facts and recent history", fn: toolMemoryShow },
-  { name: "memory_store", description: 'Persist a fact or preference to permanent memory (records.jsonl) right now. Pass { fact: "..." }', fn: toolMemoryStore },
-  { name: "memory_forget", description: 'Remove a fact or preference from permanent memory (records.jsonl). Pass { fact: "thing to forget" }', fn: toolMemoryForget },
-  { name: "lessons", description: "Show permanent failure rules learned from past tasks", fn: toolLessons },
-  { name: "skills_list", description: "List all loaded skills with descriptions", fn: toolSkillsList },
-  { name: "tools_list", description: "List all registered tool names", fn: toolToolsList },
-  { name: "whoami", description: "Show current user profile: name, home dir, platform", fn: toolWhoami },
-  { name: "channels_status", description: "Show provider channel status: active, disabled, no-key", fn: toolChannelsStatus },
-  { name: "goals", description: "Show currently active goals", fn: toolGoals }
-];
-var SLASH_MIRROR_TOOL_NAMES = MIRROR_TOOLS.map((t) => t.name);
-function registerSlashMirrorTools() {
-  const isDebug = (process.env.AIDEN_LOG_LEVEL || "info") === "debug";
-  for (const { name, description, fn } of MIRROR_TOOLS) {
-    registerExternalTool(name, fn, "slash-mirror");
-    if (isDebug) {
-      console.log("[SlashAsTool] Registered mirror tool: " + name + " \u2014 " + description);
-    }
-  }
-  if (!isDebug) {
-    console.log("[SlashAsTool] Registered " + MIRROR_TOOLS.length + " mirror tools (AIDEN_LOG_LEVEL=debug for detail)");
-  }
-}
+// api/server.ts
+init_slashAsTool();
 
 // core/memoryPreamble.ts
 var import_fs57 = __toESM(require("fs"));
@@ -1058877,7 +1058970,14 @@ ${cognitionHint}${memoryContext}${greetingPreamble}${sessionContext}${memoryInde
       }
     }
     console.error("[Router] All providers failed. Last error:", err?.message ?? "unknown");
-    send({ token: buildDiagnostic({ tool: "respond", provider: "all", retries: 2, error: "All AI providers failed or are at capacity", suggestion: "Try again in a few minutes, or add more API keys in Settings \u2192 API Keys." }), done: false, provider: "error" });
+    const poolDiag = diagnoseProviderPool();
+    send({ token: buildDiagnostic({
+      tool: "respond",
+      provider: "all",
+      retries: 2,
+      error: poolDiag.state === "unconfigured" ? "No API keys configured" : "All AI providers failed or are at capacity",
+      suggestion: poolDiag.state === "unconfigured" ? "Add API keys in Settings > API Keys, or start Ollama for local inference." : "Try again in a few minutes, or add more API keys in Settings > API Keys."
+    }), done: false, provider: "error" });
   }
   streamEnded = true;
   clearTimeout(timeout);