memorix 1.0.7 → 1.0.9

package/dist/index.js

@@ -76,6 +76,7 @@ function getDatabase(dataDir) {
   db2.exec(CREATE_TEAM_ROLES_TABLE);
   db2.exec(CREATE_GRAPH_ENTITIES_TABLE);
   db2.exec(CREATE_GRAPH_RELATIONS_TABLE);
+  db2.exec(CREATE_CHAT_TRANSCRIPT_TABLE);
   try {
     db2.exec(`ALTER TABLE mini_skills ADD COLUMN sourceSnapshot TEXT NOT NULL DEFAULT ''`);
   } catch {
@@ -115,7 +116,7 @@ function getDatabase(dataDir) {
   _dbCache.set(normalized, db2);
   return db2;
 }
-var BetterSqlite3, CREATE_OBSERVATIONS_TABLE, CREATE_MINI_SKILLS_TABLE, CREATE_SESSIONS_TABLE, CREATE_META_TABLE, CREATE_TEAM_AGENTS_TABLE, CREATE_TEAM_MESSAGES_TABLE, CREATE_TEAM_TASKS_TABLE, CREATE_TEAM_TASK_DEPS_TABLE, CREATE_TEAM_LOCKS_TABLE, CREATE_TEAM_ROLES_TABLE, CREATE_GRAPH_ENTITIES_TABLE, CREATE_GRAPH_RELATIONS_TABLE, CREATE_INDEXES, _dbCache;
+var BetterSqlite3, CREATE_OBSERVATIONS_TABLE, CREATE_MINI_SKILLS_TABLE, CREATE_SESSIONS_TABLE, CREATE_META_TABLE, CREATE_TEAM_AGENTS_TABLE, CREATE_TEAM_MESSAGES_TABLE, CREATE_TEAM_TASKS_TABLE, CREATE_TEAM_TASK_DEPS_TABLE, CREATE_TEAM_LOCKS_TABLE, CREATE_TEAM_ROLES_TABLE, CREATE_CHAT_TRANSCRIPT_TABLE, CREATE_GRAPH_ENTITIES_TABLE, CREATE_GRAPH_RELATIONS_TABLE, CREATE_INDEXES, _dbCache;
 var init_sqlite_db = __esm({
   "src/store/sqlite-db.ts"() {
     "use strict";
@@ -263,6 +264,19 @@ CREATE TABLE IF NOT EXISTS team_roles (
   max_concurrent        INTEGER NOT NULL DEFAULT 1,
   created_at            INTEGER NOT NULL
 );
+`;
+    CREATE_CHAT_TRANSCRIPT_TABLE = `
+CREATE TABLE IF NOT EXISTS chat_transcript (
+  id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  project_id      TEXT NOT NULL,
+  thread_id       TEXT NOT NULL DEFAULT 'default',
+  role            TEXT NOT NULL,
+  content         TEXT NOT NULL DEFAULT '',
+  sources_json    TEXT NOT NULL DEFAULT '[]',
+  meta_json       TEXT NOT NULL DEFAULT '{}',
+  error           INTEGER NOT NULL DEFAULT 0,
+  created_at      TEXT NOT NULL
+);
 `;
     CREATE_GRAPH_ENTITIES_TABLE = `
 CREATE TABLE IF NOT EXISTS graph_entities (
@@ -298,6 +312,7 @@ CREATE INDEX IF NOT EXISTS idx_team_tasks_role ON team_tasks(required_role);
 CREATE INDEX IF NOT EXISTS idx_team_messages_role ON team_messages(to_role);
 CREATE INDEX IF NOT EXISTS idx_graph_relations_from ON graph_relations(from_entity);
 CREATE INDEX IF NOT EXISTS idx_graph_relations_to ON graph_relations(to_entity);
+CREATE INDEX IF NOT EXISTS idx_chat_transcript_project ON chat_transcript(project_id, thread_id);
 `;
     _dbCache = /* @__PURE__ */ new Map();
   }
@@ -480,16 +495,19 @@ __export(persistence_exports, {
 import { promises as fs4 } from "fs";
 import path5 from "path";
 import os from "os";
+function resolveDefaultDataDir() {
+  return process.env.MEMORIX_DATA_DIR || path5.join(os.homedir(), ".memorix", "data");
+}
 async function getProjectDataDir(_projectId, baseDir) {
-  const base = baseDir ?? DEFAULT_DATA_DIR;
+  const base = baseDir ?? resolveDefaultDataDir();
   await fs4.mkdir(base, { recursive: true });
   return base;
 }
 function getBaseDataDir(baseDir) {
-  return baseDir ?? DEFAULT_DATA_DIR;
+  return baseDir ?? resolveDefaultDataDir();
 }
 async function listProjectDirs(baseDir) {
-  const base = baseDir ?? DEFAULT_DATA_DIR;
+  const base = baseDir ?? resolveDefaultDataDir();
   try {
     const entries = await fs4.readdir(base, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).map((e) => path5.join(base, e.name));
@@ -498,7 +516,7 @@ async function listProjectDirs(baseDir) {
   }
 }
 async function migrateSubdirsToFlat(baseDir) {
-  const base = baseDir ?? DEFAULT_DATA_DIR;
+  const base = baseDir ?? resolveDefaultDataDir();
   await fs4.mkdir(base, { recursive: true });
   let entries;
   try {
@@ -648,17 +666,22 @@ async function hasExistingData(projectDir2) {
     return false;
   }
 }
-var DEFAULT_DATA_DIR;
 var init_persistence = __esm({
   "src/store/persistence.ts"() {
     "use strict";
     init_esm_shims();
     init_persistence_json();
-    DEFAULT_DATA_DIR = process.env.MEMORIX_DATA_DIR || path5.join(os.homedir(), ".memorix", "data");
   }
 });
 
 // src/store/graph-store.ts
+var graph_store_exports = {};
+__export(graph_store_exports, {
+  GraphSqliteStore: () => GraphSqliteStore,
+  getGraphStore: () => getGraphStore,
+  initGraphStore: () => initGraphStore,
+  resetGraphStore: () => resetGraphStore
+});
 import path6 from "path";
 import fs5 from "fs";
 function safeJsonParse(val, fallback) {
@@ -694,6 +717,16 @@ function getGraphStore() {
   if (!_graphStore) throw new Error("[memorix] GraphStore not initialized \u2014 call initGraphStore() first");
   return _graphStore;
 }
+function resetGraphStore() {
+  if (_graphStore) {
+    try {
+      _graphStore.close();
+    } catch {
+    }
+  }
+  _graphStore = null;
+  _graphDataDir = null;
+}
 var GraphSqliteStore, _graphStore, _graphDataDir;
 var init_graph_store = __esm({
   "src/store/graph-store.ts"() {
@@ -1016,16 +1049,17 @@ var init_types = __esm({
     "use strict";
     init_esm_shims();
     OBSERVATION_ICONS = {
-      "session-request": "\u{1F3AF}",
-      "gotcha": "\u{1F534}",
-      "problem-solution": "\u{1F7E1}",
-      "how-it-works": "\u{1F535}",
-      "what-changed": "\u{1F7E2}",
-      "discovery": "\u{1F7E3}",
-      "why-it-exists": "\u{1F7E0}",
-      "decision": "\u{1F7E4}",
-      "trade-off": "\u2696\uFE0F",
-      "reasoning": "\u{1F9E0}"
+      "session-request": "[SESSION]",
+      "gotcha": "[GOTCHA]",
+      "problem-solution": "[FIX]",
+      "how-it-works": "[INFO]",
+      "what-changed": "[CHANGE]",
+      "discovery": "[DISCOVERY]",
+      "why-it-exists": "[WHY]",
+      "decision": "[DECISION]",
+      "trade-off": "[TRADEOFF]",
+      "reasoning": "[REASONING]",
+      "probe": "[PROBE]"
     };
     TOPIC_KEY_FAMILIES = {
       "architecture": ["architecture", "design", "adr", "structure", "pattern"],
@@ -1039,6 +1073,15 @@ var init_types = __esm({
 });
 
 // src/store/mini-skill-store.ts
+var mini_skill_store_exports = {};
+__export(mini_skill_store_exports, {
+  MiniSkillGracefulDegrade: () => MiniSkillGracefulDegrade,
+  MiniSkillSqliteStore: () => MiniSkillSqliteStore,
+  getMiniSkillStore: () => getMiniSkillStore,
+  initMiniSkillStore: () => initMiniSkillStore,
+  isMiniSkillStoreInitialized: () => isMiniSkillStoreInitialized,
+  resetMiniSkillStore: () => resetMiniSkillStore
+});
 import path7 from "path";
 import fs6 from "fs";
 function skillToRow(skill) {
@@ -1092,6 +1135,10 @@ function getMiniSkillStore() {
   }
   return _store;
 }
+function resetMiniSkillStore() {
+  _store = null;
+  _storeDataDir = null;
+}
 async function initMiniSkillStore(dataDir) {
   if (_store && _storeDataDir === dataDir) return _store;
   _store = null;
@@ -1338,6 +1385,12 @@ async function promoteToMiniSkill(projectDir2, projectId, observations2, options
       `Cannot promote: ${nonActive.length} observation(s) are not active. Blocked: ${nonActive.map((o) => `#${o.id} (${o.status ?? "unknown"})`).join(", ")}. Only active observations can be promoted to permanent knowledge.`
     );
   }
+  const probes = observations2.filter((o) => o.type === "probe");
+  if (probes.length > 0) {
+    throw new Error(
+      `Cannot promote probe observations \u2014 they are operational heartbeats, not durable knowledge. Blocked: ${probes.map((o) => `#${o.id} "${o.title.substring(0, 60)}"`).join(", ")}.`
+    );
+  }
   if (!options?.force) {
     const commandLogs = observations2.filter((o) => COMMAND_LOG_TITLE.test(o.title));
     if (commandLogs.length > 0) {
@@ -1412,7 +1465,7 @@ async function recordMiniSkillUsage(projectDir2, skillIds) {
 function formatMiniSkillsForInjection(skills) {
   if (skills.length === 0) return "";
   const lines = [
-    `## \u{1F3AF} Project Mini-Skills (${skills.length} active)`,
+    `## [SESSION] Project Mini-Skills (${skills.length} active)`,
     ""
   ];
   for (const skill of skills) {
@@ -2968,6 +3021,8 @@ var init_intent_detector = __esm({
 var provider_exports2 = {};
 __export(provider_exports2, {
   callLLM: () => callLLM,
+  callLLMWithTools: () => callLLMWithTools,
+  callLLMWithToolsStream: () => callLLMWithToolsStream,
   getLLMConfig: () => getLLMConfig,
   initLLM: () => initLLM,
   isLLMEnabled: () => isLLMEnabled,
@@ -2987,6 +3042,59 @@ function parseLLMTimeoutMs(raw) {
   if (parsed > LLM_TIMEOUT_MAX_MS) return LLM_TIMEOUT_MAX_MS;
   return parsed;
 }
+async function readResponseText(response, signal, maxBytes = MAX_LLM_RESPONSE_BYTES) {
+  const contentLength = response.headers.get("content-length");
+  if (contentLength && Number(contentLength) > maxBytes) {
+    throw new Error(`LLM response too large (${contentLength} bytes)`);
+  }
+  const reader = response.body?.getReader();
+  if (!reader) {
+    signal?.throwIfAborted();
+    return response.text();
+  }
+  const decoder = new TextDecoder();
+  const chunks = [];
+  let bytesRead = 0;
+  const abortReader = () => {
+    void reader.cancel(signal?.reason).catch(() => void 0);
+  };
+  signal?.addEventListener("abort", abortReader, { once: true });
+  try {
+    while (true) {
+      signal?.throwIfAborted();
+      const { value, done } = await reader.read();
+      if (done) break;
+      signal?.throwIfAborted();
+      if (!value) continue;
+      bytesRead += value.byteLength;
+      if (bytesRead > maxBytes) {
+        await reader.cancel("response too large").catch(() => void 0);
+        throw new Error(`LLM response exceeded ${maxBytes} bytes`);
+      }
+      chunks.push(decoder.decode(value, { stream: true }));
+    }
+    chunks.push(decoder.decode());
+    signal?.throwIfAborted();
+    return chunks.join("");
+  } finally {
+    signal?.removeEventListener("abort", abortReader);
+    reader.releaseLock();
+  }
+}
+async function readResponseJson(response, signal, maxBytes = MAX_LLM_RESPONSE_BYTES) {
+  const text = await readResponseText(response, signal, maxBytes);
+  return JSON.parse(text);
+}
+async function* callLLMWithToolsStream(messages, tools) {
+  if (!currentConfig) {
+    throw new Error("LLM not configured. Set MEMORIX_LLM_API_KEY or OPENAI_API_KEY.");
+  }
+  if (currentConfig.provider === "anthropic") {
+    yield* callAnthropicWithToolsStream(messages, tools);
+    return;
+  }
+  yield* callOpenAIWithToolsStream(messages, tools);
+}
 function initLLM() {
   const { getLLMApiKey: getLLMApiKey2, getLLMProvider: getLLMProvider2, getLLMModel: getLLMModel2, getLLMBaseUrl: getLLMBaseUrl2 } = (init_config(), __toCommonJS(config_exports));
   const apiKey = getLLMApiKey2();
@@ -3045,10 +3153,10 @@ async function callOpenAICompatible(systemPrompt, userMessage) {
     })
   });
   if (!response.ok) {
-    const error = await response.text().catch(() => "unknown error");
+    const error = await readResponseText(response, void 0, 64 * 1024).catch(() => "unknown error");
     throw new Error(`LLM API error (${response.status}): ${error}`);
   }
-  const data = await response.json();
+  const data = await readResponseJson(response);
   return {
     content: data.choices[0]?.message?.content ?? "",
     usage: data.usage ? {
@@ -3079,10 +3187,10 @@ async function callAnthropic(systemPrompt, userMessage) {
     })
   });
   if (!response.ok) {
-    const error = await response.text().catch(() => "unknown error");
+    const error = await readResponseText(response, void 0, 64 * 1024).catch(() => "unknown error");
     throw new Error(`Anthropic API error (${response.status}): ${error}`);
   }
-  const data = await response.json();
+  const data = await readResponseJson(response);
   return {
     content: data.content[0]?.text ?? "",
     usage: data.usage ? {
@@ -3091,7 +3199,418 @@ async function callAnthropic(systemPrompt, userMessage) {
     } : void 0
   };
 }
-var LLM_TIMEOUT_DEFAULT_MS, LLM_TIMEOUT_MIN_MS, LLM_TIMEOUT_MAX_MS, LLM_CALL_TIMEOUT_MS, PROVIDER_DEFAULTS, currentConfig;
+async function callLLMWithTools(messages, tools, signal) {
+  if (!currentConfig) {
+    throw new Error("LLM not configured. Set MEMORIX_LLM_API_KEY or OPENAI_API_KEY.");
+  }
+  if (currentConfig.provider === "anthropic") {
+    return callAnthropicWithTools(messages, tools, signal);
+  }
+  return callOpenAIWithTools(messages, tools, signal);
+}
+async function callOpenAIWithTools(messages, tools, signal) {
+  const config = currentConfig;
+  let base = config.baseUrl.replace(/\/+$/, "");
+  if (!base.endsWith("/v1")) base += "/v1";
+  const url = `${base}/chat/completions`;
+  const openaiMessages = messages.map((msg) => {
+    if (msg.role === "tool") {
+      return { role: "tool", content: msg.content, tool_call_id: msg.toolCallId };
+    }
+    if (msg.role === "assistant" && msg.toolCalls && msg.toolCalls.length > 0) {
+      return {
+        role: "assistant",
+        content: msg.content || null,
+        tool_calls: msg.toolCalls.map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: { name: tc.name, arguments: tc.arguments }
+        }))
+      };
+    }
+    return { role: msg.role, content: msg.content };
+  });
+  const openaiTools = tools.map((t) => ({
+    type: "function",
+    function: { name: t.name, description: t.description, parameters: t.parameters }
+  }));
+  const fetchSignal = signal ? AbortSignal.any([signal, AbortSignal.timeout(LLM_CALL_TIMEOUT_MS)]) : AbortSignal.timeout(LLM_CALL_TIMEOUT_MS);
+  const response = await fetch(url, {
+    signal: fetchSignal,
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${config.apiKey}`
+    },
+    body: JSON.stringify({
+      model: config.model,
+      messages: openaiMessages,
+      tools: openaiTools.length > 0 ? openaiTools : void 0,
+      temperature: 0.3,
+      max_tokens: 2048
+    })
+  });
+  if (!response.ok) {
+    const error = await readResponseText(response, signal, 64 * 1024).catch(() => "unknown error");
+    throw new Error(`LLM tool-call API error (${response.status}): ${error}`);
+  }
+  const data = await readResponseJson(response, signal);
+  const choice = data.choices[0];
+  const content = choice?.message?.content ?? "";
+  const toolCalls = (choice?.message?.tool_calls ?? []).map((tc) => ({
+    id: tc.id,
+    name: tc.function.name,
+    arguments: tc.function.arguments
+  }));
+  const stopReason = choice?.finish_reason === "tool_calls" ? "tool_use" : choice?.finish_reason === "stop" ? "stop" : "unknown";
+  return {
+    content,
+    toolCalls,
+    stopReason,
+    usage: data.usage ? {
+      promptTokens: data.usage.prompt_tokens,
+      completionTokens: data.usage.completion_tokens
+    } : void 0
+  };
+}
+async function callAnthropicWithTools(messages, tools, signal) {
+  const config = currentConfig;
+  const url = `${config.baseUrl}/messages`;
+  const systemContent = messages.find((m) => m.role === "system")?.content ?? "";
+  const nonSystemMessages = messages.filter((m) => m.role !== "system");
+  const anthropicMessages = [];
+  for (const msg of nonSystemMessages) {
+    if (msg.role === "user") {
+      anthropicMessages.push({ role: "user", content: msg.content });
+    } else if (msg.role === "assistant") {
+      const contentBlocks = [];
+      if (msg.content) contentBlocks.push({ type: "text", text: msg.content });
+      if (msg.toolCalls) {
+        for (const tc of msg.toolCalls) {
+          contentBlocks.push({
+            type: "tool_use",
+            id: tc.id,
+            name: tc.name,
+            input: JSON.parse(tc.arguments)
+          });
+        }
+      }
+      anthropicMessages.push({ role: "assistant", content: contentBlocks });
+    } else if (msg.role === "tool") {
+      anthropicMessages.push({
+        role: "user",
+        content: [{
+          type: "tool_result",
+          tool_use_id: msg.toolCallId,
+          content: msg.content
+        }]
+      });
+    }
+  }
+  const anthropicTools = tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.parameters
+  }));
+  const fetchSignal = signal ? AbortSignal.any([signal, AbortSignal.timeout(LLM_CALL_TIMEOUT_MS)]) : AbortSignal.timeout(LLM_CALL_TIMEOUT_MS);
+  const response = await fetch(url, {
+    signal: fetchSignal,
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": config.apiKey,
+      "anthropic-version": "2023-06-01"
+    },
+    body: JSON.stringify({
+      model: config.model,
+      system: systemContent,
+      messages: anthropicMessages,
+      tools: anthropicTools.length > 0 ? anthropicTools : void 0,
+      temperature: 0.3,
+      max_tokens: 2048
+    })
+  });
+  if (!response.ok) {
+    const error = await readResponseText(response, signal, 64 * 1024).catch(() => "unknown error");
+    throw new Error(`Anthropic tool-call API error (${response.status}): ${error}`);
+  }
+  const data = await readResponseJson(response, signal);
+  let content = "";
+  const toolCalls = [];
+  for (const block of data.content) {
+    if (block.type === "text" && block.text) {
+      content += block.text;
+    } else if (block.type === "tool_use" && block.id && block.name) {
+      toolCalls.push({
+        id: block.id,
+        name: block.name,
+        arguments: JSON.stringify(block.input ?? {})
+      });
+    }
+  }
+  const stopReason = data.stop_reason === "tool_use" ? "tool_use" : data.stop_reason === "end_turn" ? "end_turn" : "unknown";
+  return {
+    content,
+    toolCalls,
+    stopReason,
+    usage: data.usage ? {
+      promptTokens: data.usage.input_tokens,
+      completionTokens: data.usage.output_tokens
+    } : void 0
+  };
+}
+async function* callOpenAIWithToolsStream(messages, tools) {
+  const config = currentConfig;
+  let base = config.baseUrl.replace(/\/+$/, "");
+  if (!base.endsWith("/v1")) base += "/v1";
+  const url = `${base}/chat/completions`;
+  const openaiMessages = messages.map((msg) => {
+    if (msg.role === "tool") {
+      return { role: "tool", content: msg.content, tool_call_id: msg.toolCallId };
+    }
+    if (msg.role === "assistant" && msg.toolCalls && msg.toolCalls.length > 0) {
+      return {
+        role: "assistant",
+        content: msg.content || null,
+        tool_calls: msg.toolCalls.map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: { name: tc.name, arguments: tc.arguments }
+        }))
+      };
+    }
+    return { role: msg.role, content: msg.content };
+  });
+  const openaiTools = tools.map((t) => ({
+    type: "function",
+    function: { name: t.name, description: t.description, parameters: t.parameters }
+  }));
+  const response = await fetch(url, {
+    signal: AbortSignal.timeout(LLM_CALL_TIMEOUT_MS * 2),
+    // longer timeout for streaming
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${config.apiKey}`
+    },
+    body: JSON.stringify({
+      model: config.model,
+      messages: openaiMessages,
+      tools: openaiTools.length > 0 ? openaiTools : void 0,
+      temperature: 0.3,
+      max_tokens: 2048,
+      stream: true
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text().catch(() => "unknown error");
+    throw new Error(`LLM streaming API error (${response.status}): ${error}`);
+  }
+  const reader = response.body?.getReader();
+  if (!reader) throw new Error("No response body for streaming");
+  const decoder = new TextDecoder();
+  let fullContent = "";
+  const toolCallMap = /* @__PURE__ */ new Map();
+  let finishReason = "unknown";
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed === "data: [DONE]") continue;
+        if (!trimmed.startsWith("data: ")) continue;
+        try {
+          const chunk = JSON.parse(trimmed.slice(6));
+          const delta = chunk.choices?.[0]?.delta;
+          if (!delta) continue;
+          if (delta.content) {
+            fullContent += delta.content;
+            yield { type: "text", content: delta.content };
+          }
+          if (delta.tool_calls) {
+            for (const tc of delta.tool_calls) {
+              const idx = tc.index ?? 0;
+              if (!toolCallMap.has(idx)) {
+                toolCallMap.set(idx, {
+                  id: tc.id ?? "",
+                  name: tc.function?.name ?? "",
+                  arguments: tc.function?.arguments ?? ""
+                });
+              } else {
+                const existing = toolCallMap.get(idx);
+                if (tc.id) existing.id = tc.id;
+                if (tc.function?.name) existing.name = tc.function.name;
+                if (tc.function?.arguments) existing.arguments += tc.function.arguments;
+              }
+            }
+          }
+          if (chunk.choices?.[0]?.finish_reason) {
+            finishReason = chunk.choices[0].finish_reason;
+          }
+        } catch {
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const toolCalls = [...toolCallMap.values()].map((tc) => ({
+    id: tc.id,
+    name: tc.name,
+    arguments: tc.arguments
+  }));
+  for (const tc of toolCalls) {
+    yield { type: "tool_call", toolCall: tc };
+  }
+  const stopReason = finishReason === "tool_calls" ? "tool_use" : finishReason === "stop" ? "stop" : "unknown";
+  yield {
+    type: "done",
+    response: {
+      content: fullContent,
+      toolCalls,
+      stopReason
+    }
+  };
+}
+async function* callAnthropicWithToolsStream(messages, tools) {
+  const config = currentConfig;
+  const url = `${config.baseUrl}/messages`;
+  const systemContent = messages.find((m) => m.role === "system")?.content ?? "";
+  const nonSystemMessages = messages.filter((m) => m.role !== "system");
+  const anthropicMessages = [];
+  for (const msg of nonSystemMessages) {
+    if (msg.role === "user") {
+      anthropicMessages.push({ role: "user", content: msg.content });
+    } else if (msg.role === "assistant") {
+      const contentBlocks = [];
+      if (msg.content) contentBlocks.push({ type: "text", text: msg.content });
+      if (msg.toolCalls) {
+        for (const tc of msg.toolCalls) {
+          contentBlocks.push({
+            type: "tool_use",
+            id: tc.id,
+            name: tc.name,
+            input: JSON.parse(tc.arguments)
+          });
+        }
+      }
+      anthropicMessages.push({ role: "assistant", content: contentBlocks });
+    } else if (msg.role === "tool") {
+      anthropicMessages.push({
+        role: "user",
+        content: [{
+          type: "tool_result",
+          tool_use_id: msg.toolCallId,
+          content: msg.content
+        }]
+      });
+    }
+  }
+  const anthropicTools = tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.parameters
+  }));
+  const response = await fetch(url, {
+    signal: AbortSignal.timeout(LLM_CALL_TIMEOUT_MS * 2),
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": config.apiKey,
+      "anthropic-version": "2023-06-01"
+    },
+    body: JSON.stringify({
+      model: config.model,
+      system: systemContent,
+      messages: anthropicMessages,
+      tools: anthropicTools.length > 0 ? anthropicTools : void 0,
+      temperature: 0.3,
+      max_tokens: 2048,
+      stream: true
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text().catch(() => "unknown error");
+    throw new Error(`Anthropic streaming API error (${response.status}): ${error}`);
+  }
+  const reader = response.body?.getReader();
+  if (!reader) throw new Error("No response body for streaming");
+  const decoder = new TextDecoder();
+  let fullContent = "";
+  const toolCalls = [];
+  let currentToolId = "";
+  let currentToolName = "";
+  let currentToolInput = "";
+  let stopReason = "unknown";
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("data: ")) continue;
+        try {
+          const event = JSON.parse(trimmed.slice(6));
+          if (event.type === "content_block_delta") {
+            const delta = event.delta;
+            if (delta?.type === "text_delta" && delta.text) {
+              fullContent += delta.text;
+              yield { type: "text", content: delta.text };
+            } else if (delta?.type === "input_json_delta" && delta.partial_json) {
+              currentToolInput += delta.partial_json;
+            }
+          } else if (event.type === "content_block_start") {
+            const block = event.content_block;
+            if (block?.type === "tool_use") {
+              currentToolId = block.id ?? "";
+              currentToolName = block.name ?? "";
+              currentToolInput = "";
+            }
+          } else if (event.type === "content_block_stop") {
+            if (currentToolId && currentToolName) {
+              const tc = {
+                id: currentToolId,
+                name: currentToolName,
+                arguments: currentToolInput || "{}"
+              };
+              toolCalls.push(tc);
+              yield { type: "tool_call", toolCall: tc };
+              currentToolId = "";
+              currentToolName = "";
+              currentToolInput = "";
+            }
+          } else if (event.type === "message_delta") {
+            if (event.delta?.stop_reason) {
+              stopReason = event.delta.stop_reason;
+            }
+          }
+        } catch {
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const mappedStopReason = stopReason === "tool_use" ? "tool_use" : stopReason === "end_turn" ? "end_turn" : "unknown";
+  yield {
+    type: "done",
+    response: {
+      content: fullContent,
+      toolCalls,
+      stopReason: mappedStopReason
+    }
+  };
+}
+var LLM_TIMEOUT_DEFAULT_MS, LLM_TIMEOUT_MIN_MS, LLM_TIMEOUT_MAX_MS, MAX_LLM_RESPONSE_BYTES, LLM_CALL_TIMEOUT_MS, PROVIDER_DEFAULTS, currentConfig;
 var init_provider2 = __esm({
   "src/llm/provider.ts"() {
     "use strict";
@@ -3099,6 +3618,7 @@ var init_provider2 = __esm({
     LLM_TIMEOUT_DEFAULT_MS = 3e4;
     LLM_TIMEOUT_MIN_MS = 1e3;
     LLM_TIMEOUT_MAX_MS = 3e5;
+    MAX_LLM_RESPONSE_BYTES = 2 * 1024 * 1024;
     LLM_CALL_TIMEOUT_MS = parseLLMTimeoutMs(process.env.MEMORIX_LLM_TIMEOUT_MS);
     PROVIDER_DEFAULTS = {
       openai: { baseUrl: "https://api.openai.com/v1", model: "gpt-4.1-nano" },
@@ -3185,7 +3705,7 @@ function idPriority(id) {
   return 2;
 }
 function getRegistryPath(baseDir) {
-  return path8.join(baseDir ?? registryDir ?? DEFAULT_DATA_DIR2, ALIAS_FILE);
+  return path8.join(baseDir ?? registryDir ?? DEFAULT_DATA_DIR, ALIAS_FILE);
 }
 async function loadRegistry(baseDir) {
   if (registryCache) return registryCache;
@@ -3357,12 +3877,12 @@ function initAliasRegistry(dataDir) {
 function resetAliasCache() {
   registryCache = null;
 }
-var DEFAULT_DATA_DIR2, ALIAS_FILE, registryCache, registryDir;
+var DEFAULT_DATA_DIR, ALIAS_FILE, registryCache, registryDir;
 var init_aliases = __esm({
   "src/project/aliases.ts"() {
     "use strict";
     init_esm_shims();
-    DEFAULT_DATA_DIR2 = process.env.MEMORIX_DATA_DIR || path8.join(os2.homedir(), ".memorix", "data");
+    DEFAULT_DATA_DIR = process.env.MEMORIX_DATA_DIR || path8.join(os2.homedir(), ".memorix", "data");
     ALIAS_FILE = ".project-aliases.json";
     registryCache = null;
     registryDir = null;
@@ -3924,6 +4444,10 @@ async function searchObservations(options) {
     if (statusFilter === "all") return true;
     const doc = hit.document;
     return (doc.status || "active") === statusFilter;
+  }).filter((hit) => {
+    if (options.type === "probe") return true;
+    const doc = hit.document;
+    return doc.type !== "probe";
   }).map((hit) => {
     const doc = hit.document;
     const obsType = doc.type;
@@ -3939,7 +4463,7 @@ async function searchObservations(options) {
       time: formatTime(doc.createdAt),
       rawTime: doc.createdAt,
       type: obsType,
-      icon: OBSERVATION_ICONS[obsType] ?? "\u2753",
+      icon: OBSERVATION_ICONS[obsType] ?? "[UNKNOWN]",
       title: doc.title,
       tokens: doc.tokens,
       score: (hit.score ?? 1) * recencyBoost,
@@ -4164,7 +4688,7 @@ async function searchObservations(options) {
       } else if (isSynthesized) {
         entry.matchedFields = ["synthesized", ...reasons];
       } else if (isCore) {
-        entry.matchedFields = ["\u2605 core", ...reasons];
+        entry.matchedFields = ["core core", ...reasons];
       } else {
         entry.matchedFields = reasons;
       }
@@ -4212,7 +4736,7 @@ async function getTimeline(anchorId, projectId, depthBefore = 3, depthAfter = 3)
       id: obs.id,
       time: formatTime(obs.createdAt),
       type: obsType,
-      icon: OBSERVATION_ICONS[obsType] ?? "\u2753",
+      icon: OBSERVATION_ICONS[obsType] ?? "[UNKNOWN]",
       title: obs.title,
       tokens: obs.tokens,
       source: obs.source || void 0,
@@ -5626,10 +6150,10 @@ function resolveEvidenceBasis(fields) {
 function evidenceBasisLine(basis, commitHash) {
   if (basis === "repository") {
     const commit = commitHash ? ` \u2014 commit ${commitHash.substring(0, 7)}` : "";
-    return `\u2713 Repository-backed${commit}`;
+    return `[OK] Repository-backed${commit}`;
   }
   if (basis === "synthesized") {
-    return "\u25C8 Synthesized \u2014 explicit analysis citing repository evidence";
+    return "[SYNTHESIZED] Synthesized \u2014 explicit analysis citing repository evidence";
   }
   return "";
 }
@@ -6157,10 +6681,10 @@ var init_extract = __esm({
         pattern: /\b([A-Z][a-zA-Z_-]{2,30})\s*[:=]\s*([^\n,;]{2,60})/g,
         format: (m) => `${m[1]}: ${m[2].trim()}`
       },
-      // Arrow notation (e.g., "MySQL → PostgreSQL", "v1.0 → v2.0")
+      // Arrow notation (e.g., "MySQL -> PostgreSQL", "v1.0 -> v2.0")
       {
-        pattern: /\b(\S{2,30})\s*[→➜\->]+\s*(\S{2,30})/g,
-        format: (m) => `${m[1]} \u2192 ${m[2]}`
+        pattern: /\b(\S{2,30})\s*(?:->|=>|>)\s*(\S{2,30})/g,
+        format: (m) => `${m[1]} -> ${m[2]}`
       },
       // Version numbers (e.g., "v1.2.3", "version 2.0")
       {
@@ -6305,6 +6829,11 @@ function hasContradiction(oldText, newText) {
   ];
   return negationPatterns.some((p) => p.test(newText));
 }
+function normalizedSearchSimilarity(score) {
+  if (!Number.isFinite(score) || score <= 0) return 0;
+  if (score <= 1) return score;
+  return 0;
+}
 function mergeNarratives(oldNarrative, newNarrative) {
   if (newNarrative.length > oldNarrative.length * 1.5) return newNarrative;
   if (oldNarrative.length > newNarrative.length * 1.5) return oldNarrative;
@@ -6395,12 +6924,13 @@ function scoreCandidate(extracted, candidate) {
     `${extracted.title} ${extracted.narrative}`,
     `${candidate.title} ${candidate.narrative}`
   );
-  const score = candidate.score * 0.6 + (entityMatch ? 0.2 : 0) + contentOverlap * 0.2;
+  const searchSimilarity = normalizedSearchSimilarity(candidate.score);
+  const score = searchSimilarity * 0.6 + (entityMatch ? 0.2 : 0) + contentOverlap * 0.2;
   const newLength = extracted.narrative.length + extracted.facts.join(" ").length;
   const oldLength = candidate.narrative.length + candidate.facts.length;
   const richer = newLength > oldLength * 1.15;
   const contradiction = hasContradiction(candidate.narrative, extracted.narrative);
-  return { score, entityMatch, richer, contradiction };
+  return { score, searchSimilarity, entityMatch, richer, contradiction };
 }
 async function runResolve(extracted, projectId, searchMemories, getObservation2, useLLM = false) {
   const query = `${extracted.title} ${extracted.narrative.substring(0, 200)}`;
@@ -6423,7 +6953,7 @@ async function runResolve(extracted, projectId, searchMemories, getObservation2,
   }));
   scored.sort((a, b) => b.score - a.score);
   const best = scored[0];
-  if (best.hit.score >= SIMILARITY_DUPLICATE) {
+  if (best.searchSimilarity >= SIMILARITY_DUPLICATE) {
     if (best.richer) {
       const existing = getObservation2(best.hit.observationId);
       const oldFacts = existing?.facts ?? best.hit.facts.split("\n").filter(Boolean);
@@ -6610,7 +7140,8 @@ var init_evaluate = __esm({
       "how-it-works": 0.6,
       "discovery": 0.55,
       "what-changed": 0.45,
-      "session-request": 0.4
+      "session-request": 0.4,
+      "probe": 0.1
     };
     SPECIFICITY_PATTERNS = [
       /\b\d+\.\d+\.\d+\b/,
@@ -6820,16 +7351,36 @@ function getMetricsSummary() {
 async function runFormation(input, config) {
   const startTime = Date.now();
   let stagesCompleted = 0;
+  const stageDurationsMs = {};
+  const emitStageEvent = (stage, status, stageDurationMs) => {
+    try {
+      config.onStageEvent?.({
+        stage,
+        status,
+        stageDurationMs,
+        totalElapsedMs: Date.now() - startTime
+      });
+    } catch {
+    }
+  };
   const existingEntities = config.getEntityNames();
+  const extractStartTime = Date.now();
+  emitStageEvent("extract", "start");
   const extraction = await runExtract(input, existingEntities, config.useLLM);
+  stageDurationsMs.extract = Date.now() - extractStartTime;
+  emitStageEvent("extract", "success", stageDurationsMs.extract);
   stagesCompleted = 1;
   let resolution;
   if (input.topicKey) {
+    stageDurationsMs.resolve = 0;
+    emitStageEvent("resolve", "skipped", 0);
     resolution = {
       action: "new",
       reason: "TopicKey upsert \u2014 bypasses resolve stage"
     };
   } else {
+    const resolveStartTime = Date.now();
+    emitStageEvent("resolve", "start");
     resolution = await runResolve(
       extraction,
       input.projectId,
@@ -6837,9 +7388,15 @@ async function runFormation(input, config) {
       config.getObservation,
       config.useLLM
     );
+    stageDurationsMs.resolve = Date.now() - resolveStartTime;
+    emitStageEvent("resolve", "success", stageDurationsMs.resolve);
   }
   stagesCompleted = 2;
+  const evaluateStartTime = Date.now();
+  emitStageEvent("evaluate", "start");
   const evaluation = runEvaluate(extraction);
+  stageDurationsMs.evaluate = Date.now() - evaluateStartTime;
+  emitStageEvent("evaluate", "success", stageDurationsMs.evaluate);
   stagesCompleted = 3;
   const durationMs = Date.now() - startTime;
   const formed = {
@@ -6858,7 +7415,8 @@ async function runFormation(input, config) {
       mode: config.useLLM ? "llm" : "rules",
       durationMs,
       stagesCompleted,
-      shadow: config.mode === "shadow"
+      shadow: config.mode === "shadow",
+      stageDurationsMs
     },
     // Governance fields
     governance: {
@@ -7047,6 +7605,9 @@ function scoreObservationForSessionContext(obs, projectTokens, now = Date.now())
   if (obs.valueCategory === "core") {
     score += 2;
   }
+  if (obs.type === "probe") {
+    score -= 100;
+  }
   return score;
 }
 async function startSession(projectDir2, projectId, opts) {
@@ -7139,7 +7700,7 @@ async function getSessionContext(projectDir2, projectId, limit = 3) {
     lines.push("*Recent activity signals and search guidance for this session.*");
     if (l1HookObs.length > 0) {
       for (const obs of l1HookObs) {
-        lines.push(`\u{1F517} ${redactCredentials(obs.title)}`);
+        lines.push(`[HOOK] ${redactCredentials(obs.title)}`);
       }
       lines.push("");
     }
@@ -7157,7 +7718,7 @@ async function getSessionContext(projectDir2, projectId, limit = 3) {
       hints.push(`${totalHookCount} hook trace(s) available \u2014 use \`memorix_timeline\` for activity expansion`);
     }
     for (const hint of hints) {
-      lines.push(`\u{1F4A1} ${hint}`);
+      lines.push(`[TIP] ${hint}`);
     }
     lines.push("");
   }
@@ -7184,7 +7745,7 @@ async function getSessionContext(projectDir2, projectId, limit = 3) {
     lines.push("## Key Project Memories");
     lines.push("*Durable working context \u2014 explicit decisions, gotchas, and discoveries.*");
     for (const obs of l2Obs) {
-      const emoji = TYPE_EMOJI[obs.type] ?? "\u{1F4CC}";
+      const emoji = TYPE_EMOJI[obs.type] ?? "[PIN]";
       const fact = obs.facts?.[0] ? ` \u2014 ${redactCredentials(obs.facts[0])}` : "";
       lines.push(`${emoji} ${redactCredentials(obs.title)}${fact}`);
     }
@@ -7204,10 +7765,10 @@ async function getSessionContext(projectDir2, projectId, limit = 3) {
   }
   const l3Lines = [];
   if (l3GitCount > 0) {
-    l3Lines.push(`\u{1F4CC} ${l3GitCount} git-memory item(s) \u2014 use \`memorix_search\` to retrieve repository evidence`);
+    l3Lines.push(`[PIN] ${l3GitCount} git-memory item(s) \u2014 use \`memorix_search\` to retrieve repository evidence`);
   }
   if (totalHookCount > 0) {
-    l3Lines.push(`\u{1F517} ${totalHookCount} hook trace(s) \u2014 use \`memorix_timeline\` for full activity expansion`);
+    l3Lines.push(`[HOOK] ${totalHookCount} hook trace(s) \u2014 use \`memorix_timeline\` for full activity expansion`);
   }
   if (l3Lines.length > 0) {
     lines.push("## L3 Evidence");
@@ -7247,15 +7808,16 @@ var init_session = __esm({
     init_secret_filter();
     PRIORITY_TYPES = /* @__PURE__ */ new Set(["gotcha", "decision", "problem-solution", "trade-off", "discovery"]);
     TYPE_EMOJI = {
-      "gotcha": "\u{1F536}",
-      "decision": "\u{1F7E0}",
-      "problem-solution": "\u{1F7E1}",
-      "trade-off": "\u2696\uFE0F",
-      "discovery": "\u{1F7E3}",
-      "how-it-works": "\u{1F535}",
-      "what-changed": "\u{1F7E2}",
-      "why-it-exists": "\u{1F7E4}",
-      "session-request": "\u{1F3AF}"
+      "gotcha": "[DISCOVERY]",
+      "decision": "[WHY]",
+      "problem-solution": "[FIX]",
+      "trade-off": "[TRADEOFF]",
+      "discovery": "[DISCOVERY]",
+      "how-it-works": "[INFO]",
+      "what-changed": "[CHANGE]",
+      "why-it-exists": "[DECISION]",
+      "session-request": "[SESSION]",
+      "probe": "[PROBE]"
     };
     TYPE_WEIGHTS2 = {
       "gotcha": 6,
@@ -7334,11 +7896,17 @@ function getValueCategoryMultiplier(doc) {
   return 1;
 }
 function getEffectiveRetentionDays(doc) {
+  const typeOverride = TYPE_RETENTION_OVERRIDE[doc.type];
+  if (typeOverride !== void 0) {
+    const raw2 = typeOverride * getSourceRetentionMultiplier(doc);
+    return Math.max(MIN_RETENTION_DAYS, raw2);
+  }
   const importance = getImportanceLevel(doc);
   const raw = RETENTION_DAYS[importance] * getSourceRetentionMultiplier(doc) * getValueCategoryMultiplier(doc);
   return Math.max(MIN_RETENTION_DAYS, raw);
 }
 function isImmune(doc) {
+  if (doc.type === "probe") return false;
   if (doc.valueCategory === "core") return true;
   const importance = getImportanceLevel(doc);
   if (importance === "critical") return true;
@@ -7347,6 +7915,7 @@ function isImmune(doc) {
   return concepts.some((c) => PROTECTED_TAGS.has(c));
 }
 function getImmunityReason(doc) {
+  if (doc.type === "probe") return null;
   if (doc.valueCategory === "core") return "core valueCategory (formation-classified)";
   const importance = getImportanceLevel(doc);
   if (importance === "critical") return "critical importance";
@@ -7503,7 +8072,7 @@ async function archiveExpired(projectDir2, referenceTime, accessMap) {
     return { archived: archivedCount, remaining: activeObs.length - archivedCount };
   });
 }
-var RETENTION_DAYS, BASE_IMPORTANCE, TYPE_IMPORTANCE, PROTECTED_TAGS, MIN_ACCESS_FOR_IMMUNITY, MIN_RETENTION_DAYS;
+var RETENTION_DAYS, BASE_IMPORTANCE, TYPE_IMPORTANCE, TYPE_RETENTION_OVERRIDE, PROTECTED_TAGS, MIN_ACCESS_FOR_IMMUNITY, MIN_RETENTION_DAYS;
 var init_retention = __esm({
   "src/memory/retention.ts"() {
     "use strict";
@@ -7531,7 +8100,12 @@ var init_retention = __esm({
       "what-changed": "low",
       "why-it-exists": "medium",
       discovery: "low",
-      "session-request": "low"
+      "session-request": "low",
+      probe: "low"
+    };
+    TYPE_RETENTION_OVERRIDE = {
+      probe: 7
+      // Operational heartbeats: expire after ~7 days regardless of source/valueCategory
     };
     PROTECTED_TAGS = /* @__PURE__ */ new Set(["keep", "important", "pinned", "critical"]);
     MIN_ACCESS_FOR_IMMUNITY = 3;
@@ -7797,7 +8371,7 @@ ${narrative}`;
           lines.push("");
         }
         if (gotchas.length > 0) {
-          lines.push("## \u26A0\uFE0F Critical Gotchas");
+          lines.push("## [WARN] Critical Gotchas");
           lines.push("");
           for (const g of gotchas) {
             lines.push(`### ${g.title}`);
@@ -7809,7 +8383,7 @@ ${narrative}`;
           }
         }
         if (decisions.length > 0) {
-          lines.push("## \u{1F3D7}\uFE0F Architecture Decisions");
+          lines.push("## [BUILD] Architecture Decisions");
           lines.push("");
           for (const d of decisions) {
             lines.push(`### ${d.title}`);
@@ -7821,7 +8395,7 @@ ${narrative}`;
           }
         }
         if (howItWorks.length > 0) {
-          lines.push("## \u{1F4D6} How It Works");
+          lines.push("## [DOCS] How It Works");
           lines.push("");
           for (const h of howItWorks) {
             lines.push(`### ${h.title}`);
@@ -7830,7 +8404,7 @@ ${narrative}`;
           }
         }
         if (problems.length > 0) {
-          lines.push("## \u{1F527} Common Problems & Solutions");
+          lines.push("## [TOOL] Common Problems & Solutions");
           lines.push("");
           for (const p of problems) {
             lines.push(`### ${p.title}`);
@@ -7842,7 +8416,7 @@ ${narrative}`;
           }
         }
         if (tradeoffs.length > 0) {
-          lines.push("## \u2696\uFE0F Trade-offs");
+          lines.push("## [TRADEOFF] Trade-offs");
           lines.push("");
           for (const t of tradeoffs) {
             lines.push(`### ${t.title}`);
@@ -7851,7 +8425,7 @@ ${narrative}`;
           }
         }
         if (others.length > 0) {
-          lines.push("## \u{1F4DD} Notes");
+          lines.push("## [PLAN] Notes");
           lines.push("");
           for (const o of others.slice(0, 5)) {
             lines.push(`- **${o.title}**: ${o.narrative?.split("\n")[0] || ""}`);
@@ -7859,13 +8433,13 @@ ${narrative}`;
           lines.push("");
         }
         if (allConcepts.length > 0) {
-          lines.push("## \u{1F3F7}\uFE0F Related Concepts");
+          lines.push("## [TAG] Related Concepts");
           lines.push("");
           lines.push(allConcepts.map((c) => `\`${c}\``).join(", "));
           lines.push("");
         }
         if (allFacts.length > 0) {
-          lines.push("## \u{1F4CC} Quick Facts");
+          lines.push("## [PIN] Quick Facts");
           lines.push("");
           for (const f of allFacts.slice(0, 15)) {
             lines.push(`- ${f}`);
@@ -9096,7 +9670,7 @@ async function exportAsMarkdown(projectDir2, projectId) {
   if (Object.keys(data.stats.typeBreakdown).length > 0) {
     lines.push("## Type Distribution");
     for (const [type, count2] of Object.entries(data.stats.typeBreakdown).sort((a, b) => b[1] - a[1])) {
-      const icon = OBSERVATION_ICONS2[type] ?? "\u2753";
+      const icon = OBSERVATION_ICONS2[type] ?? "[UNKNOWN]";
       lines.push(`- ${icon} ${type}: ${count2}`);
     }
     lines.push("");
@@ -9104,7 +9678,7 @@ async function exportAsMarkdown(projectDir2, projectId) {
   if (data.sessions.length > 0) {
     lines.push("## Sessions");
     for (const s of data.sessions) {
-      const status = s.status === "active" ? "\u{1F7E2}" : "\u2705";
+      const status = s.status === "active" ? "[CHANGE]" : "[OK]";
       const agent = s.agent ? ` [${s.agent}]` : "";
       lines.push(`### ${status} ${s.id}${agent}`);
       lines.push(`Started: ${s.startedAt}${s.endedAt ? ` | Ended: ${s.endedAt}` : ""}`);
@@ -9124,7 +9698,7 @@ async function exportAsMarkdown(projectDir2, projectId) {
   for (const [entity, observations2] of byEntity) {
     lines.push(`### ${entity}`);
     for (const obs of observations2) {
-      const icon = OBSERVATION_ICONS2[obs.type] ?? "\u2753";
+      const icon = OBSERVATION_ICONS2[obs.type] ?? "[UNKNOWN]";
       lines.push(`#### ${icon} #${obs.id} ${obs.title}`);
       lines.push(`Type: ${obs.type} | Created: ${obs.createdAt}${obs.topicKey ? ` | Topic: ${obs.topicKey}` : ""}${obs.revisionCount && obs.revisionCount > 1 ? ` | Rev: ${obs.revisionCount}` : ""}`);
       lines.push("");
@@ -9190,15 +9764,15 @@ var init_export_import = __esm({
     init_obs_store();
     init_session_store();
     OBSERVATION_ICONS2 = {
-      "session-request": "\u{1F3AF}",
-      "gotcha": "\u{1F534}",
-      "problem-solution": "\u{1F7E1}",
-      "how-it-works": "\u{1F535}",
-      "what-changed": "\u{1F7E2}",
-      "discovery": "\u{1F7E3}",
-      "why-it-exists": "\u{1F7E0}",
-      "decision": "\u{1F7E4}",
-      "trade-off": "\u2696\uFE0F"
+      "session-request": "[SESSION]",
+      "gotcha": "[GOTCHA]",
+      "problem-solution": "[FIX]",
+      "how-it-works": "[INFO]",
+      "what-changed": "[CHANGE]",
+      "discovery": "[DISCOVERY]",
+      "why-it-exists": "[WHY]",
+      "decision": "[DECISION]",
+      "trade-off": "[TRADEOFF]"
     };
   }
 });
@@ -9259,6 +9833,449 @@ var init_project_classification = __esm({
   }
 });
 
+// src/wiki/generator.ts
+var generator_exports = {};
+__export(generator_exports, {
+  contextualHasSubstance: () => contextualHasSubstance,
+  generateKnowledgeBase: () => generateKnowledgeBase,
+  isCommandLog: () => isCommandLog,
+  isEligible: () => isEligible,
+  isExcludedType: () => isExcludedType
+});
+function isExcludedType(o) {
+  return o.type === "probe";
+}
+function isCommandLog(o) {
+  return COMMAND_LOG_TITLE3.test(o.title || "");
+}
+function isInactive(o) {
+  const status = o.status ?? "active";
+  return status !== "active";
+}
+function isOtherProject(o, projectId) {
+  return o.projectId !== projectId;
+}
+function contextualHasSubstance(o) {
+  if (o.valueCategory !== "contextual") return true;
+  const hasFacts = (o.facts?.length ?? 0) > 0;
+  const hasConcepts = (o.concepts?.length ?? 0) > 0;
+  const hasFiles = (o.filesModified?.length ?? 0) > 0;
+  const hasEntity = !!(o.entityName && o.entityName !== "quick-note" && o.entityName !== "unknown");
+  return hasFacts || hasConcepts || hasFiles || hasEntity;
+}
+function isEligible(o, projectId) {
+  if (isExcludedType(o)) return false;
+  if (isCommandLog(o)) return false;
+  if (isInactive(o)) return false;
+  if (isOtherProject(o, projectId)) return false;
+  if (o.valueCategory === "ephemeral") return false;
+  if (!contextualHasSubstance(o)) return false;
+  return true;
+}
+function obsToItem(o) {
+  const ref = {
+    kind: o.source === "git" ? "git" : "observation",
+    id: `obs:${o.id}`,
+    title: o.title
+  };
+  return {
+    title: o.title,
+    summary: o.narrative?.slice(0, 200) || "",
+    type: o.type,
+    entityName: o.entityName || void 0,
+    refs: [ref]
+  };
+}
+function skillToItem(s) {
+  const ref = {
+    kind: "mini-skill",
+    id: `skill:${s.id}`,
+    title: s.title
+  };
+  const obsRefs = s.sourceObservationIds.map(
+    (oid) => ({ kind: "observation", id: `obs:${oid}` })
+  );
+  return {
+    title: s.title,
+    summary: s.instruction?.slice(0, 200) || "",
+    type: "mini-skill",
+    entityName: s.sourceEntity || void 0,
+    refs: [ref, ...obsRefs]
+  };
+}
+function buildGitSection(observations2) {
+  const gitObs = observations2.filter(
+    (o) => o.source === "git" && o.sourceDetail === "git-ingest"
+  );
+  const items = gitObs.map(obsToItem);
+  return {
+    id: "git-backed-facts",
+    title: "Git-backed Facts",
+    items,
+    empty: items.length === 0
+  };
+}
+function buildSkillsSection(skills) {
+  const items = skills.map(skillToItem);
+  return {
+    id: "promoted-skills",
+    title: "Promoted Skills",
+    items,
+    empty: items.length === 0
+  };
+}
+function buildProjectOverview(projectId, eligibleObs, skills) {
+  const refs = [
+    ...eligibleObs.slice(0, 5).map((o) => ({
+      kind: o.source === "git" ? "git" : "observation",
+      id: `obs:${o.id}`,
+      title: o.title
+    })),
+    ...skills.slice(0, 5).map((s) => ({
+      kind: "mini-skill",
+      id: `skill:${s.id}`,
+      title: s.title
+    }))
+  ];
+  if (refs.length === 0) {
+    return {
+      id: "project-overview",
+      title: "Project Overview",
+      items: [],
+      empty: true
+    };
+  }
+  const lines = [];
+  lines.push(`Project: ${projectId}`);
+  lines.push(`Observations in KB: ${eligibleObs.length}`);
+  lines.push(`Promoted skills: ${skills.length}`);
+  const entityCounts = /* @__PURE__ */ new Map();
+  for (const o of eligibleObs) {
+    if (o.entityName) {
+      entityCounts.set(o.entityName, (entityCounts.get(o.entityName) || 0) + 1);
+    }
+  }
+  const topEntities = [...entityCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5);
+  if (topEntities.length > 0) {
+    lines.push(`Top entities: ${topEntities.map(([name, count2]) => `${name} (${count2})`).join(", ")}`);
+  }
+  return {
+    id: "project-overview",
+    title: "Project Overview",
+    items: [{
+      title: projectId,
+      summary: lines.join("\n"),
+      type: "overview",
+      refs
+    }]
+  };
+}
+function generateKnowledgeBase(options) {
+  const { projectId, observations: observations2, miniSkills } = options;
+  const eligible = observations2.filter((o) => isEligible(o, projectId));
+  const scopedMiniSkills = miniSkills.filter((s) => s.projectId === projectId);
+  const typedSections = SECTION_DEFS.map((def) => {
+    const matched = eligible.filter(def.typeMatch);
+    const items = matched.map(obsToItem);
+    return {
+      id: def.id,
+      title: def.title,
+      items,
+      empty: items.length === 0
+    };
+  });
+  const projectOverview = buildProjectOverview(projectId, eligible, scopedMiniSkills);
+  const gitSection = buildGitSection(eligible);
+  const skillsSection = buildSkillsSection(scopedMiniSkills);
+  const sections = [
+    projectOverview,
+    ...typedSections,
+    gitSection,
+    skillsSection
+  ];
+  const allRefs = sections.flatMap((s) => s.items.flatMap((i) => i.refs));
+  const obsRefCount = allRefs.filter((r) => r.kind === "observation" || r.kind === "git").length;
+  const skillRefCount = allRefs.filter((r) => r.kind === "mini-skill").length;
+  return {
+    title: "Knowledge Base",
+    subtitle: "LLM Wiki",
+    projectId,
+    generatedAt: options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    sections,
+    stats: {
+      observationsUsed: eligible.length,
+      miniSkillsUsed: scopedMiniSkills.length,
+      refs: obsRefCount + skillRefCount
+    }
+  };
+}
+var COMMAND_LOG_TITLE3, SECTION_DEFS;
+var init_generator = __esm({
+  "src/wiki/generator.ts"() {
+    "use strict";
+    init_esm_shims();
+    COMMAND_LOG_TITLE3 = /^(Ran:|Command:|Executed:)\s/i;
+    SECTION_DEFS = [
+      {
+        id: "core-decisions",
+        title: "Core Decisions",
+        typeMatch: (o) => o.type === "decision" || o.type === "trade-off" || o.type === "reasoning"
+      },
+      {
+        id: "operational-knowledge",
+        title: "Operational Knowledge",
+        typeMatch: (o) => o.type === "how-it-works" || o.type === "what-changed" || o.type === "why-it-exists" || o.type === "discovery" || o.type === "session-request"
+      },
+      {
+        id: "known-gotchas",
+        title: "Known Gotchas",
+        typeMatch: (o) => o.type === "gotcha" || o.type === "problem-solution"
+      }
+    ];
+  }
+});
+
+// src/wiki/knowledge-graph.ts
+var knowledge_graph_exports = {};
+__export(knowledge_graph_exports, {
+  generateKnowledgeGraph: () => generateKnowledgeGraph
+});
+function inferEdges(nodes, entityNameIndex) {
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  const maxRelatesEdgesPerEntitySection = 8;
+  function addEdge(source, target, edgeType) {
+    const key = `${source}:${edgeType}:${target}`;
+    if (seen.has(key)) return;
+    if (source === target) return;
+    seen.add(key);
+    edges.push({
+      id: `e_${edges.length}_${source}_${target}`,
+      source,
+      target,
+      edgeType
+    });
+  }
+  function rankNodesForEntity(a, b) {
+    const evidenceDiff = (b.evidenceCount || 0) - (a.evidenceCount || 0);
+    if (evidenceDiff !== 0) return evidenceDiff;
+    return a.id.localeCompare(b.id);
+  }
+  for (const [, group] of entityNameIndex) {
+    if (group.length < 2) continue;
+    const bySection = /* @__PURE__ */ new Map();
+    for (const node of group) {
+      const sectionGroup = bySection.get(node.sectionId) || [];
+      sectionGroup.push(node);
+      bySection.set(node.sectionId, sectionGroup);
+    }
+    for (const sectionGroup of bySection.values()) {
+      const ranked = [...sectionGroup].sort(rankNodesForEntity);
+      if (ranked.length === 2) {
+        addEdge(ranked[0].id, ranked[1].id, "relates_to");
+        addEdge(ranked[1].id, ranked[0].id, "relates_to");
+        continue;
+      }
+      const anchor = ranked[0];
+      for (const node of ranked.slice(1, maxRelatesEdgesPerEntitySection + 1)) {
+        addEdge(anchor.id, node.id, "relates_to");
+      }
+    }
+    const sectionAnchors = [...bySection.entries()].map(([sectionId, sectionGroup]) => ({
+      sectionId,
+      anchor: [...sectionGroup].sort(rankNodesForEntity)[0]
+    })).sort((a, b) => sectionPriority(a.sectionId) - sectionPriority(b.sectionId));
+    for (let i = 0; i < sectionAnchors.length; i++) {
+      for (let j = i + 1; j < sectionAnchors.length; j++) {
+        const from = sectionAnchors[i].anchor;
+        const to = sectionAnchors[j].anchor;
+        const edgeType = sectionPriority(sectionAnchors[i].sectionId) === sectionPriority(sectionAnchors[j].sectionId) ? "relates_to" : "supports";
+        addEdge(from.id, to.id, edgeType);
+      }
+    }
+  }
+  return edges;
+}
+function sectionPriority(sectionId) {
+  const order = ["core-decisions", "known-gotchas", "operational-knowledge", "git-backed-facts", "promoted-skills"];
+  const idx = order.indexOf(sectionId);
+  return idx >= 0 ? idx : order.length;
+}
+function sectionIdForObs(o) {
+  if (GIT_SECTION.typeMatch(o)) return GIT_SECTION.id;
+  for (const def of SECTION_DEFS2) {
+    if (def.typeMatch(o)) return def.id;
+  }
+  return "operational-knowledge";
+}
+function mapRelationType(relationType) {
+  const lower = relationType.toLowerCase();
+  if (lower.includes("support") || lower.includes("depend")) return "supports";
+  if (lower.includes("relat") || lower.includes("connect") || lower.includes("associat")) return "relates_to";
+  if (lower.includes("mention") || lower.includes("refer")) return "mentions";
+  if (lower.includes("deriv") || lower.includes("origin") || lower.includes("source")) return "derived_from";
+  return "relates_to";
+}
+function generateKnowledgeGraph(options) {
+  const { projectId, observations: observations2, miniSkills, graphEntities, graphRelations } = options;
+  const eligible = observations2.filter((o) => isEligible(o, projectId));
+  const scopedMiniSkills = miniSkills.filter((s) => s.projectId === projectId);
+  const nodes = [];
+  const entityNameIndex = /* @__PURE__ */ new Map();
+  for (const o of eligible) {
+    const sectionId = sectionIdForObs(o);
+    const ref = {
+      kind: o.source === "git" ? "git" : "observation",
+      id: `obs:${o.id}`,
+      title: o.title
+    };
+    const node = {
+      id: `obs:${o.id}`,
+      label: o.title,
+      nodeType: o.type,
+      sectionId,
+      entityName: o.entityName || void 0,
+      evidenceCount: (o.facts?.length ?? 0) + (o.concepts?.length ?? 0) + (o.filesModified?.length ?? 0),
+      summary: o.narrative?.slice(0, 200) || "",
+      refs: [ref]
+    };
+    nodes.push(node);
+    if (o.entityName) {
+      const group = entityNameIndex.get(o.entityName) || [];
+      group.push(node);
+      entityNameIndex.set(o.entityName, group);
+    }
+  }
+  for (const s of scopedMiniSkills) {
+    const ref = {
+      kind: "mini-skill",
+      id: `skill:${s.id}`,
+      title: s.title
+    };
+    const obsRefs = s.sourceObservationIds.map(
+      (oid) => ({ kind: "observation", id: `obs:${oid}` })
+    );
+    const node = {
+      id: `skill:${s.id}`,
+      label: s.title,
+      nodeType: "mini-skill",
+      sectionId: "promoted-skills",
+      entityName: s.sourceEntity || void 0,
+      evidenceCount: obsRefs.length,
+      summary: s.instruction?.slice(0, 200) || "",
+      refs: [ref, ...obsRefs]
+    };
+    nodes.push(node);
+    if (s.sourceEntity) {
+      const group = entityNameIndex.get(s.sourceEntity) || [];
+      group.push(node);
+      entityNameIndex.set(s.sourceEntity, group);
+    }
+  }
+  const edges = inferEdges(nodes, entityNameIndex);
+  for (const s of scopedMiniSkills) {
+    const skillNodeId = `skill:${s.id}`;
+    for (const oid of s.sourceObservationIds) {
+      const obsNodeId = `obs:${oid}`;
+      if (nodes.some((n) => n.id === obsNodeId)) {
+        edges.push({
+          id: `e_${edges.length}_${skillNodeId}_${obsNodeId}`,
+          source: skillNodeId,
+          target: obsNodeId,
+          edgeType: "derived_from"
+        });
+      }
+    }
+  }
+  if (graphRelations && graphRelations.length > 0) {
+    const entityNodeMap = /* @__PURE__ */ new Map();
+    for (const n of nodes) {
+      if (n.entityName && !entityNodeMap.has(n.entityName)) {
+        entityNodeMap.set(n.entityName, n.id);
+      }
+    }
+    const seen = new Set(edges.map((e) => `${e.source}:${e.edgeType}:${e.target}`));
+    for (const rel of graphRelations) {
+      const srcId = entityNodeMap.get(rel.from);
+      const tgtId = entityNodeMap.get(rel.to);
+      if (!srcId || !tgtId) continue;
+      if (srcId === tgtId) continue;
+      const edgeType = mapRelationType(rel.relationType);
+      const key = `${srcId}:${edgeType}:${tgtId}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      edges.push({
+        id: `e_gr_${edges.length}_${srcId}_${tgtId}`,
+        source: srcId,
+        target: tgtId,
+        edgeType
+      });
+    }
+  }
+  const sectionCounts = {};
+  for (const n of nodes) {
+    sectionCounts[n.sectionId] = (sectionCounts[n.sectionId] || 0) + 1;
+  }
+  const clusters = ALL_SECTIONS.filter((def) => (sectionCounts[def.id] ?? 0) > 0).map((def) => ({
+    id: `cluster:${def.id}`,
+    label: def.label,
+    sectionId: def.id,
+    nodeCount: sectionCounts[def.id] ?? 0
+  }));
+  const stats = {
+    totalNodes: nodes.length,
+    totalEdges: edges.length,
+    clusterCount: clusters.length,
+    sectionCounts
+  };
+  return {
+    title: "Knowledge Graph",
+    projectId,
+    generatedAt: options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    nodes,
+    edges,
+    clusters,
+    stats
+  };
+}
+var SECTION_DEFS2, GIT_SECTION, SKILLS_SECTION, ALL_SECTIONS;
+var init_knowledge_graph = __esm({
+  "src/wiki/knowledge-graph.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_generator();
+    SECTION_DEFS2 = [
+      {
+        id: "core-decisions",
+        label: "Core Decisions",
+        typeMatch: (o) => o.type === "decision" || o.type === "trade-off" || o.type === "reasoning"
+      },
+      {
+        id: "operational-knowledge",
+        label: "Operational Knowledge",
+        typeMatch: (o) => o.type === "how-it-works" || o.type === "what-changed" || o.type === "why-it-exists" || o.type === "discovery" || o.type === "session-request"
+      },
+      {
+        id: "known-gotchas",
+        label: "Known Gotchas",
+        typeMatch: (o) => o.type === "gotcha" || o.type === "problem-solution"
+      }
+    ];
+    GIT_SECTION = {
+      id: "git-backed-facts",
+      label: "Git-backed Facts",
+      typeMatch: (o) => o.source === "git" && o.sourceDetail === "git-ingest"
+    };
+    SKILLS_SECTION = {
+      id: "promoted-skills",
+      label: "Promoted Skills",
+      typeMatch: () => false
+      // skills handled separately
+    };
+    ALL_SECTIONS = [...SECTION_DEFS2, GIT_SECTION, SKILLS_SECTION];
+  }
+});
+
 // src/dashboard/server.ts
 var server_exports = {};
 __export(server_exports, {
@@ -9281,6 +10298,12 @@ function sendError(res, message, status = 500) {
 function filterByProject(items, projectId) {
   return items.filter((item) => item.projectId === projectId);
 }
+function isActiveStatus(status) {
+  return (status ?? "active") === "active";
+}
+function filterActiveByProject(items, projectId) {
+  return items.filter((item) => item.projectId === projectId && isActiveStatus(item.status));
+}
 function computeProjectGraphCounts(allEntities, allRelations, projectObs) {
   const entityNames = new Set(
     projectObs.filter((o) => (o.status ?? "active") === "active" && o.entityName).map((o) => o.entityName)
@@ -9313,6 +10336,7 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
           const allObs = await getObservationStore().loadAll();
           const projectSet = /* @__PURE__ */ new Map();
           for (const obs of allObs) {
+            if (!isActiveStatus(obs.status)) continue;
             if (obs.projectId) {
               projectSet.set(obs.projectId, (projectSet.get(obs.projectId) || 0) + 1);
             }
@@ -9370,7 +10394,7 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
       }
       case "/observations": {
         const allObs = await getObservationStore().loadAll();
-        const observations2 = filterByProject(allObs, effectiveProjectId);
+        const observations2 = filterActiveByProject(allObs, effectiveProjectId);
         sendJson(res, observations2);
         break;
       }
@@ -9384,12 +10408,16 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
         await initGraphStore(effectiveDataDir);
         const graph = { entities: getGraphStore().loadEntities(), relations: getGraphStore().loadRelations() };
         const allObs = await getObservationStore().loadAll();
-        const observations2 = filterByProject(allObs, effectiveProjectId);
+        const observations2 = filterActiveByProject(
+          allObs,
+          effectiveProjectId
+        );
         const nextId2 = await getObservationStore().loadIdCounter();
         const projectGraphCounts = computeProjectGraphCounts(graph.entities, graph.relations, observations2);
         const typeCounts = {};
         for (const obs of observations2) {
           const t = obs.type || "unknown";
+          if (t === "probe") continue;
           typeCounts[t] = (typeCounts[t] || 0) + 1;
         }
         const sourceCounts = { git: 0, agent: 0, manual: 0 };
@@ -9431,7 +10459,7 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
           else if (score >= 1) retentionSummary.stale++;
           else retentionSummary.archive++;
         }
-        const sorted = [...observations2].sort((a, b) => (b.id || 0) - (a.id || 0)).slice(0, 10);
+        const sorted = [...observations2].filter((o) => o.type !== "probe").sort((a, b) => (b.id || 0) - (a.id || 0)).slice(0, 10);
         let embeddingStatus = { enabled: false, provider: "", dimensions: 0 };
         try {
           const { getEmbeddingProvider: getEmbeddingProvider2 } = await Promise.resolve().then(() => (init_provider(), provider_exports));
@@ -9469,9 +10497,9 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
       }
       case "/retention": {
         const allObs = await getObservationStore().loadAll();
-        const observations2 = filterByProject(allObs, effectiveProjectId);
+        const observations2 = filterActiveByProject(allObs, effectiveProjectId);
         const now = Date.now();
-        const scored = observations2.map((obs) => {
+        const scored = observations2.filter((obs) => obs.type !== "probe").map((obs) => {
           const age = now - new Date(obs.createdAt || now).getTime();
           const ageHours = age / (1e3 * 60 * 60);
           const importance = obs.importance ?? 5;
@@ -9503,6 +10531,50 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
         });
         break;
       }
+      case "/knowledge": {
+        const { generateKnowledgeBase: generateKnowledgeBase2 } = await Promise.resolve().then(() => (init_generator(), generator_exports));
+        const { initObservations: initObservations2, getAllObservations: getAllObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
+        const { initMiniSkillStore: initMiniSkillStore2, getMiniSkillStore: getMiniSkillStore2 } = await Promise.resolve().then(() => (init_mini_skill_store(), mini_skill_store_exports));
+        await initObservations2(effectiveDataDir);
+        await initMiniSkillStore2(effectiveDataDir);
+        const allObs = getAllObservations2();
+        const skills = await getMiniSkillStore2().loadByProject(effectiveProjectId);
+        const overview = generateKnowledgeBase2({
+          projectId: effectiveProjectId,
+          observations: allObs,
+          miniSkills: skills
+        });
+        sendJson(res, overview);
+        break;
+      }
+      case "/knowledge-graph": {
+        const { generateKnowledgeGraph: generateKnowledgeGraph2 } = await Promise.resolve().then(() => (init_knowledge_graph(), knowledge_graph_exports));
+        const { initObservations: initObservations2, getAllObservations: getAllObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
+        const { initMiniSkillStore: initMiniSkillStore2, getMiniSkillStore: getMiniSkillStore2 } = await Promise.resolve().then(() => (init_mini_skill_store(), mini_skill_store_exports));
+        const { initGraphStore: initGraphStore2, getGraphStore: getGraphStore2 } = await Promise.resolve().then(() => (init_graph_store(), graph_store_exports));
+        await initObservations2(effectiveDataDir);
+        await initMiniSkillStore2(effectiveDataDir);
+        await initGraphStore2(effectiveDataDir);
+        const allObs = getAllObservations2();
+        const skills = await getMiniSkillStore2().loadByProject(effectiveProjectId);
+        const fullGraph = { entities: getGraphStore2().loadEntities(), relations: getGraphStore2().loadRelations() };
+        const graphObs = await getObservationStore().loadAll();
+        const projectEntityNames = new Set(
+          graphObs.filter((o) => o.projectId === effectiveProjectId && (o.status ?? "active") === "active" && o.entityName).map((o) => o.entityName)
+        );
+        const scopedEntities = fullGraph.entities.filter((e) => projectEntityNames.has(e.name));
+        const scopedEntityNameSet = new Set(scopedEntities.map((e) => e.name));
+        const scopedRelations = fullGraph.relations.filter((r) => scopedEntityNameSet.has(r.from) && scopedEntityNameSet.has(r.to));
+        const graph = generateKnowledgeGraph2({
+          projectId: effectiveProjectId,
+          observations: allObs,
+          miniSkills: skills,
+          graphEntities: scopedEntities,
+          graphRelations: scopedRelations
+        });
+        sendJson(res, graph);
+        break;
+      }
       case "/config": {
         const os4 = await import("os");
         const { existsSync: existsSync10 } = await import("fs");
@@ -9694,7 +10766,7 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
           await initGraphStore(effectiveDataDir);
           const fullGraph = { entities: getGraphStore().loadEntities(), relations: getGraphStore().loadRelations() };
           const allObs = await getObservationStore().loadAll();
-          const observations2 = filterByProject(allObs, effectiveProjectId);
+          const observations2 = filterActiveByProject(allObs, effectiveProjectId);
           const nextId2 = await getObservationStore().loadIdCounter();
           const exportEntityNames = new Set(
             observations2.filter((o) => (o.status ?? "active") === "active" && o.entityName).map((o) => o.entityName)
@@ -9739,13 +10811,20 @@ async function serveStatic(req, res, staticDir) {
     const ext = path14.extname(filePath);
     res.writeHead(200, {
       "Content-Type": MIME_TYPES[ext] || "application/octet-stream",
-      "Cache-Control": "no-cache"
+      "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
+      "Pragma": "no-cache",
+      "Expires": "0"
     });
     res.end(data);
   } catch {
     try {
       const indexData = await fs12.readFile(path14.join(staticDir, "index.html"));
-      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.writeHead(200, {
+        "Content-Type": "text/html; charset=utf-8",
+        "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
+        "Pragma": "no-cache",
+        "Expires": "0"
+      });
       res.end(indexData);
     } catch {
       sendError(res, "Not found", 404);
@@ -9757,6 +10836,131 @@ function openBrowser(url) {
   exec(cmd, () => {
   });
 }
+function parseJsonField(value, fallback) {
+  if (typeof value !== "string") return value ?? fallback;
+  try {
+    return JSON.parse(value || JSON.stringify(fallback));
+  } catch {
+    return fallback;
+  }
+}
+function normalizeDashboardAgent(teamStore, projectId, agent) {
+  const id = agent.agent_id ?? agent.id ?? "";
+  const agentProjectId = agent.project_id ?? agent.projectId ?? projectId;
+  return {
+    id,
+    projectId: agentProjectId,
+    instanceId: agent.instance_id ?? agent.instanceId,
+    agentType: agent.agent_type ?? agent.agentType,
+    name: agent.name,
+    role: agent.role,
+    capabilities: parseJsonField(agent.capabilities, []),
+    status: agent.status,
+    joinedAt: agent.joined_at ?? agent.joinedAt,
+    lastSeenAt: agent.last_heartbeat ?? agent.last_seen_at ?? agent.lastSeenAt,
+    leftAt: agent.left_at ?? agent.leftAt,
+    unread: id ? teamStore.getUnreadCount(agentProjectId, id) : 0,
+    source: agent.source || "sqlite"
+  };
+}
+function normalizeDashboardLock(lock) {
+  return {
+    file: lock.file,
+    projectId: lock.project_id ?? lock.projectId,
+    lockedBy: lock.locked_by ?? lock.lockedBy,
+    lockedAt: lock.locked_at ?? lock.lockedAt,
+    expiresAt: lock.expires_at ?? lock.expiresAt
+  };
+}
+function normalizeDashboardTask(task) {
+  return {
+    id: task.task_id ?? task.id,
+    projectId: task.project_id ?? task.projectId,
+    description: task.description,
+    status: task.status,
+    assignee: task.assignee_agent_id ?? task.assignee,
+    result: task.result,
+    metadata: parseJsonField(task.metadata, null),
+    createdBy: task.created_by ?? task.createdBy,
+    createdAt: task.created_at ?? task.createdAt,
+    updatedAt: task.updated_at ?? task.updatedAt,
+    deps: task.deps || [],
+    requiredRole: task.required_role ?? task.requiredRole ?? null,
+    preferredRole: task.preferred_role ?? task.preferredRole ?? null
+  };
+}
+async function buildTeamSnapshot(dataDir, projectId, scope, mode) {
+  try {
+    const { initTeamStore: initTeamStore2 } = await Promise.resolve().then(() => (init_team_store(), team_store_exports));
+    const teamStore = await initTeamStore2(dataDir);
+    const effectiveProjectId = scope === "global" ? void 0 : projectId;
+    const rawAgents = effectiveProjectId ? teamStore.listAgents(effectiveProjectId) : teamStore.listAllAgents();
+    const rawLocks = effectiveProjectId ? teamStore.listLocks(effectiveProjectId) : teamStore.listAllLocks();
+    const rawTasks = effectiveProjectId ? teamStore.listTasks(effectiveProjectId) : teamStore.listAllTasks();
+    const available = effectiveProjectId ? teamStore.listTasks(effectiveProjectId, { available: true }) : teamStore.listAllTasks({ available: true });
+    const agents = rawAgents.map((agent) => normalizeDashboardAgent(teamStore, projectId, agent));
+    const locks = rawLocks.map(normalizeDashboardLock);
+    const tasks = rawTasks.map(normalizeDashboardTask);
+    const recentWindowMs = 7 * 24 * 60 * 60 * 1e3;
+    const now = Date.now();
+    const withTier = agents.map((agent) => {
+      if (agent.status === "active") return { ...agent, activityTier: "active" };
+      const seen = Date.parse(agent.lastSeenAt ?? "") || 0;
+      return { ...agent, activityTier: now - seen <= recentWindowMs ? "recent" : "historical" };
+    });
+    const activeCount = withTier.filter((agent) => agent.activityTier === "active").length;
+    const recentCount = withTier.filter((agent) => agent.activityTier === "recent").length;
+    const historicalCount = withTier.filter((agent) => agent.activityTier === "historical").length;
+    const roles = effectiveProjectId ? teamStore.listRoles(effectiveProjectId) : [];
+    const roleOccupancy = effectiveProjectId ? teamStore.getRoleOccupancy(effectiveProjectId) : [];
+    const handoffs = effectiveProjectId ? teamStore.listHandoffs(effectiveProjectId) : [];
+    return {
+      mode,
+      readOnly: mode === "standalone",
+      scope,
+      agents: withTier,
+      activeCount,
+      recentCount,
+      historicalCount,
+      totalAgents: withTier.length,
+      recentWindowDays: 7,
+      locks,
+      tasks,
+      availableTasks: available.length,
+      sessions: 0,
+      roles,
+      roleOccupancy,
+      handoffs,
+      openTasks: tasks.filter((task) => task.status === "pending" || task.status === "in_progress").length,
+      openHandoffs: handoffs.filter((handoff) => handoff.handoff_status === "open" || handoff.handoffStatus === "open").length,
+      totalUnread: withTier.reduce((sum, agent) => sum + (agent.unread || 0), 0),
+      activeSessions: activeCount
+    };
+  } catch {
+    return {
+      mode,
+      readOnly: mode === "standalone",
+      scope,
+      agents: [],
+      activeCount: 0,
+      recentCount: 0,
+      historicalCount: 0,
+      totalAgents: 0,
+      recentWindowDays: 7,
+      locks: [],
+      tasks: [],
+      availableTasks: 0,
+      sessions: 0,
+      roles: [],
+      roleOccupancy: [],
+      handoffs: [],
+      openTasks: 0,
+      openHandoffs: 0,
+      totalUnread: 0,
+      activeSessions: 0
+    };
+  }
+}
 function readBody(req) {
   return new Promise((resolve, reject) => {
     const chunks = [];
@@ -9795,7 +10999,9 @@ async function startDashboard(dataDir, port, staticDir, projectId, projectName,
     }
     if (url.startsWith("/api/team")) {
       if (!teamInstances) {
-        sendJson(res, { unavailable: true, reason: "http-transport-required" });
+        const parsedUrl = new URL(url, `http://127.0.0.1:${port}`);
+        const scope = parsedUrl.searchParams.get("scope") || "project";
+        sendJson(res, await buildTeamSnapshot(state.dataDir, state.projectId, scope, state.mode));
         return;
       }
       try {
@@ -10583,7 +11789,7 @@ function buildReviewIterationHint(iteration, maxIterations, budgetRemaining) {
   if (iteration >= maxIterations) {
     return `
 
-\u26A0\uFE0F This is the FINAL review iteration (${iteration}/${maxIterations}). Do NOT create more tasks. Summarize remaining issues and exit.`;
+[WARN] This is the FINAL review iteration (${iteration}/${maxIterations}). Do NOT create more tasks. Summarize remaining issues and exit.`;
   }
   return `
 
@@ -11089,6 +12295,8 @@ import { spawnSync } from 'node:child_process';
 export const MemorixPlugin = async ({ project, client, $, directory, worktree }) => {
   // Generate a stable session ID for this plugin lifetime
   const sessionId = \`opencode-\${Date.now().toString(36)}-\${Math.random().toString(36).slice(2, 8)}\`;
+  let pendingAssistantResponse = null;
+  let lastDeliveredAssistantKey = '';
 
   /**
    * Send event JSON to \`memorix hook\` via child_process.spawnSync.
@@ -11121,6 +12329,33 @@ export const MemorixPlugin = async ({ project, client, $, directory, worktree })
     }
   }
 
+  function extractMessageInfo(input) {
+    if (input && typeof input === 'object') {
+      if (input.info && typeof input.info === 'object') return input.info;
+      if (input.message && typeof input.message === 'object') return input.message;
+      if (input.properties && typeof input.properties === 'object') {
+        if (input.properties.info && typeof input.properties.info === 'object') return input.properties.info;
+        if (input.properties.message && typeof input.properties.message === 'object') return input.properties.message;
+      }
+    }
+    return input;
+  }
+
+  function extractMessageText(message) {
+    if (!message || typeof message !== 'object') return '';
+    if (typeof message.content === 'string') return message.content.trim();
+    const parts = Array.isArray(message.parts) ? message.parts : [];
+    return parts
+      .map((part) => {
+        if (!part || typeof part !== 'object') return '';
+        if (typeof part.text === 'string') return part.text;
+        if (typeof part.content === 'string') return part.content;
+        return '';
+      })
+      .join('')
+      .trim();
+  }
+
   return {
     /** Session created \u2014 record session start */
     'session.created': async ({ session }) => {
@@ -11133,6 +12368,21 @@ export const MemorixPlugin = async ({ project, client, $, directory, worktree })
 
     /** Session idle \u2014 record session end */
     'session.idle': async ({ session }) => {
+      if (pendingAssistantResponse?.text) {
+        const deliveryKey = pendingAssistantResponse.id
+          ? \`\${pendingAssistantResponse.id}:\${pendingAssistantResponse.text}\`
+          : pendingAssistantResponse.text;
+        if (deliveryKey !== lastDeliveredAssistantKey) {
+          runHook({
+            agent: 'opencode',
+            hook_event_name: 'message.updated',
+            ai_response: pendingAssistantResponse.text,
+            message_id: pendingAssistantResponse.id,
+            cwd: directory,
+          });
+          lastDeliveredAssistantKey = deliveryKey;
+        }
+      }
       runHook({
         agent: 'opencode',
         hook_event_name: 'session.idle',
@@ -11161,6 +12411,19 @@ export const MemorixPlugin = async ({ project, client, $, directory, worktree })
       });
     },
 
+    /** Message updated \u2014 cache the latest assistant response until session.idle */
+    'message.updated': async (input, output) => {
+      const message = extractMessageInfo(input);
+      const role = message?.role ?? input?.role ?? input?.info?.role;
+      if (role !== 'assistant') return;
+      const text = extractMessageText(message);
+      if (!text) return;
+      pendingAssistantResponse = {
+        id: message?.id ?? input?.id ?? input?.messageID,
+        text,
+      };
+    },
+
     /** Session compacted \u2014 record post-compact event */
     'session.compacted': async ({ session }) => {
       runHook({
@@ -11410,7 +12673,7 @@ async function installHooks(agent, projectRoot, global = false) {
       return {
         agent,
         configPath: pluginPath,
-        events: ["session_start", "session_end", "post_tool", "post_edit", "post_compact", "post_command"],
+        events: ["session_start", "session_end", "post_tool", "post_edit", "post_compact", "post_command", "post_response"],
         generated: { note: "OpenCode plugin installed at " + pluginPath }
       };
     }
@@ -11617,6 +12880,7 @@ At the **beginning of every conversation**, BEFORE responding to the user:
 
 **Important:** \`projectRoot\` is a detection anchor only; Git remains the source of truth for project identity.
 In HTTP control-plane mode (\`memorix serve-http\` / \`memorix background start\`), explicit \`projectRoot\` binding is required for correct multi-project isolation.
+\`memorix_session_start\` is lightweight by default: it starts memory/session context only. Do not set \`joinTeam\` unless the user explicitly needs autonomous Agent Team tasks, messages, file locks, or orchestrated CLI-agent workflows.
 
 ## RULE 2: Store Important Context
 
@@ -11717,7 +12981,7 @@ This file contains the **minimum operating rules** for Memorix memory tools. It
 For authoritative, up-to-date details on:
 - **Support tiers** (core / extended / community) and what "installed" vs "runtime-ready" means
 - **HTTP control-plane binding** and \`projectRoot\` isolation rules
-- **Role-aware team semantics** (required_role, preferred_role, task claim, handoff validation)
+- **Opt-in team semantics** (\`joinTeam\`, \`team_manage join\`, roles, task claim, handoff validation)
 - **Install vs runtime-ready distinction** \u2014 hook config written \u2260 agent will execute it
 - **Agent-specific caveats** (Copilot project-level only, OpenCode plugin lifecycle, etc.)
 
@@ -11733,7 +12997,7 @@ async function uninstallHooks(agent, projectRoot, global = false) {
   const configPath = global ? getGlobalConfigPath(agent) : getProjectConfigPath(agent, projectRoot);
   let success = false;
   try {
-    if (agent === "kiro") {
+    if (agent === "kiro" || agent === "opencode") {
       await fs14.unlink(configPath);
       success = true;
     } else {
@@ -11867,7 +13131,7 @@ var init_installers = __esm({
   "src/hooks/installers/index.ts"() {
     "use strict";
     init_esm_shims();
-    OPENCODE_PLUGIN_VERSION = 5;
+    OPENCODE_PLUGIN_VERSION = 6;
   }
 });
 
@@ -12026,6 +13290,7 @@ init_obs_store();
 init_orama_store();
 init_mini_skill_store();
 init_session_store();
+import { createHash as createHash4 } from "crypto";
 import { watchFile } from "fs";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z as z2 } from "zod";
@@ -12295,7 +13560,7 @@ function formatTimeline(timeline) {
   const anchorEffectiveSource = resolveSourceDetail(anchor.sourceDetail, anchor.source);
   if (hasSrc && anchorEffectiveSource) {
     const anchorBasis = resolveEvidenceBasis({ sourceDetail: anchor.sourceDetail, source: anchor.source });
-    const basisSuffix = anchorBasis === "repository" ? " \u2014 \u2713 repository-backed" : anchorBasis === "synthesized" ? " \u2014 \u25C8 synthesized" : "";
+    const basisSuffix = anchorBasis === "repository" ? " \u2014 [OK] repository-backed" : anchorBasis === "synthesized" ? " \u2014 [SYNTHESIZED] synthesized" : "";
     lines.push(`*Expanding: ${sourceKindLabel(anchorEffectiveSource)}${basisSuffix}*`);
   }
   lines.push("");
@@ -12375,38 +13640,39 @@ function buildProvenanceHeader(sourceDetail, valueCategory, source, commitHash,
     lines.push(verificationLine);
   }
   if (valueCategory === "core") {
-    lines.push("\u2605 Core \u2014 immune to decay");
+    lines.push("[CORE] Core \u2014 immune to decay");
   } else if (valueCategory === "ephemeral") {
-    lines.push("\u26A0 Ephemeral \u2014 short-lived signal");
+    lines.push("[WARN] Ephemeral \u2014 short-lived signal");
   }
   return lines.join("\n");
 }
 function sourceKindLabel(sd) {
-  if (sd === "git-ingest") return "\u{1F4CC} Git Repository Evidence";
-  if (sd === "hook") return "\u{1F517} Hook Trace";
-  return "\u{1F4BE} Explicit Working Memory";
+  if (sd === "git-ingest") return "[PIN] Git Repository Evidence";
+  if (sd === "hook") return "[HOOK] Hook Trace";
+  return "[STORE] Explicit Working Memory";
 }
 function getTypeIcon(type) {
   const icons = {
-    "session-request": "\u{1F3AF}",
-    "gotcha": "\u{1F534}",
-    "problem-solution": "\u{1F7E1}",
-    "how-it-works": "\u{1F535}",
-    "what-changed": "\u{1F7E2}",
-    "discovery": "\u{1F7E3}",
-    "why-it-exists": "\u{1F7E0}",
-    "decision": "\u{1F7E4}",
-    "trade-off": "\u2696\uFE0F",
-    "reasoning": "\u{1F9E0}"
+    "session-request": "[SESSION]",
+    "gotcha": "[GOTCHA]",
+    "problem-solution": "[FIX]",
+    "how-it-works": "[INFO]",
+    "what-changed": "[CHANGE]",
+    "discovery": "[DISCOVERY]",
+    "why-it-exists": "[WHY]",
+    "decision": "[DECISION]",
+    "trade-off": "[TRADEOFF]",
+    "reasoning": "[REASONING]",
+    "probe": "[PROBE]"
   };
-  return icons[type] ?? "\u2753";
+  return icons[type] ?? "[UNKNOWN]";
 }
 function getProgressiveDisclosureHint(hasProject) {
   const lines = [
-    "\u{1F4A1} **Progressive Disclosure:** This index shows WHAT exists and retrieval COST.",
+    "[TIP] **Progressive Disclosure:** This index shows WHAT exists and retrieval COST.",
     "- Use `memorix_detail` with typed refs (obs:42, skill:3) to fetch full details",
     "- Use `memorix_timeline` to see chronological context around an observation",
-    "- Critical types (\u{1F534} gotcha, \u{1F7E4} decision, \u2696\uFE0F trade-off) are often worth fetching immediately"
+    "- Critical types ([GOTCHA] gotcha, [DECISION] decision, [TRADEOFF] trade-off) are often worth fetching immediately"
   ];
   if (hasProject) {
     lines.push("- For global results, prefer `memorix_detail refs=[{ id, projectId }]` to avoid cross-project ID ambiguity");
@@ -12417,7 +13683,7 @@ function formatEntryRef(entry) {
   return entry.documentType === "mini-skill" ? `skill:${entry.id}` : `obs:${entry.id}`;
 }
 function formatLayerBadge(layer) {
-  if (layer === "promoted") return "\u2605";
+  if (layer === "promoted") return "core";
   if (layer === "evidence") return "ev";
   return "-";
 }
@@ -12590,7 +13856,7 @@ async function compactDetail(idsOrRefs) {
         (o) => o.source === "git" && projectIds.has(o.projectId) && o.commitHash && obs.relatedCommits.includes(o.commitHash)
       );
       for (const gm of gitMems) {
-        refs2.push(`  \u2192 #${gm.id} \u{1F7E2} ${gm.title}`);
+        refs2.push(`  \u2192 #${gm.id} [CHANGE] ${gm.title}`);
       }
     }
     if (obs.relatedEntities && obs.relatedEntities.length > 0) {
@@ -12603,7 +13869,7 @@ async function compactDetail(idsOrRefs) {
       if (analysis.length > 0) {
         refs2.push("Analysis:");
         for (const r of analysis) {
-          refs2.push(`  \u2192 #${r.id} ${r.type === "reasoning" ? "\u{1F9E0}" : "\u{1F7E4}"} ${r.title}`);
+          refs2.push(`  \u2192 #${r.id} ${r.type === "reasoning" ? "[REASONING]" : "[DECISION]"} ${r.title}`);
         }
       }
     }
@@ -12614,7 +13880,7 @@ async function compactDetail(idsOrRefs) {
       if (gitMems.length > 0) {
         refs2.push("Repository evidence:");
         for (const g of gitMems) {
-          refs2.push(`  \u2192 #${g.id} \u{1F7E2} ${g.title}`);
+          refs2.push(`  \u2192 #${g.id} [CHANGE] ${g.title}`);
         }
       }
     }
@@ -12653,7 +13919,7 @@ async function compactDetail(idsOrRefs) {
 }
 function formatMiniSkillDetail(skill, provenanceStatus) {
   const lines = [];
-  lines.push(`S${skill.id} \u2605 ${skill.title}`);
+  lines.push(`S${skill.id} core ${skill.title}`);
   lines.push("=".repeat(50));
   lines.push(`Type: promoted knowledge (mini-skill)`);
   lines.push(`Entity: ${skill.sourceEntity}`);
@@ -14697,47 +15963,47 @@ var WorkspaceSyncEngine = class _WorkspaceSyncEngine {
     }
     const lines = [];
     if (applyResult.success) {
-      lines.push(`\u2705 Applied ${applyResult.filesWritten.length} file(s) for ${target}`);
+      lines.push(`[OK] Applied ${applyResult.filesWritten.length} file(s) for ${target}`);
       for (const f of applyResult.filesWritten) {
         lines.push(`  \u2192 ${f}`);
       }
       if (skillResult.copied.length > 0) {
         lines.push(`
-\u{1F9E9} Copied ${skillResult.copied.length} skill(s):`);
+[SKILL] Copied ${skillResult.copied.length} skill(s):`);
         for (const sk of skillResult.copied) {
           lines.push(`  \u2192 ${sk}`);
         }
       }
       if (skillResult.skipped.length > 0) {
         lines.push(`
-\u23ED\uFE0F Skipped ${skillResult.skipped.length} skill(s):`);
+[SKIP] Skipped ${skillResult.skipped.length} skill(s):`);
         for (const sk of skillResult.skipped) {
           lines.push(`  \u2192 ${sk}`);
         }
       }
       if (syncResult.skills.conflicts.length > 0) {
         lines.push(`
-\u26A0\uFE0F Name conflicts (${syncResult.skills.conflicts.length}):`);
+[WARN] Name conflicts (${syncResult.skills.conflicts.length}):`);
         for (const c of syncResult.skills.conflicts) {
           lines.push(`  \u2192 "${c.name}": kept ${c.kept.sourceAgent}, skipped ${c.skipped.sourceAgent}`);
         }
       }
       if (applyResult.backups.length > 0) {
         lines.push(`
-\u{1F4E6} Backups created (${applyResult.backups.length}):`);
+[PACKAGE] Backups created (${applyResult.backups.length}):`);
         for (const b of applyResult.backups) {
           lines.push(`  ${b.originalPath} \u2192 ${b.backupPath}`);
         }
       }
       applier.cleanBackups(applyResult.backups);
     } else {
-      lines.push(`\u274C Apply failed for ${target}`);
+      lines.push(`[ERROR] Apply failed for ${target}`);
       for (const e of applyResult.errors) {
         lines.push(`  Error: ${e}`);
       }
       if (applyResult.backups.length > 0) {
         lines.push(`
-\u{1F504} Rolled back ${applyResult.backups.length} file(s)`);
+[UPDATED] Rolled back ${applyResult.backups.length} file(s)`);
       }
     }
     return {
@@ -14763,11 +16029,109 @@ var WorkspaceSyncEngine = class _WorkspaceSyncEngine {
   }
 };
 
+// src/server/tool-profile.ts
+init_esm_shims();
+var TOOL_PROFILES = Object.freeze({
+  // ── lite: core cross-agent memory — always available ──────────────
+  memorix_store: ["lite", "team", "full"],
+  memorix_search: ["lite", "team", "full"],
+  memorix_detail: ["lite", "team", "full"],
+  memorix_resolve: ["lite", "team", "full"],
+  memorix_timeline: ["lite", "team", "full"],
+  memorix_suggest_topic_key: ["lite", "team", "full"],
+  memorix_session_start: ["lite", "team", "full"],
+  memorix_session_end: ["lite", "team", "full"],
+  memorix_session_context: ["lite", "team", "full"],
+  memorix_store_reasoning: ["lite", "team", "full"],
+  memorix_search_reasoning: ["lite", "team", "full"],
+  memorix_transfer: ["lite", "team", "full"],
+  memorix_retention: ["lite", "team", "full"],
+  // ── team: autonomous agent team surfaces — HTTP default ───────────
+  memorix_dashboard: ["team", "full"],
+  memorix_handoff: ["team", "full"],
+  memorix_poll: ["team", "full"],
+  team_manage: ["team", "full"],
+  team_message: ["team", "full"],
+  team_task: ["team", "full"],
+  team_file_lock: ["team", "full"],
+  // ── full: advanced / specialized — opt-in only ───────────────────
+  memorix_audit_project: ["full"],
+  memorix_deduplicate: ["full"],
+  memorix_consolidate: ["full"],
+  memorix_formation_metrics: ["full"],
+  memorix_skills: ["full"],
+  memorix_promote: ["full"],
+  memorix_rules_sync: ["full"],
+  memorix_workspace_sync: ["full"],
+  memorix_ingest_image: ["full"],
+  // ── MCP Official Memory Server compatibility (KG tools) ──────────
+  // These are only useful to users specifically migrating from the
+  // reference mcp-memory server. Hide them unless explicitly enabled.
+  create_entities: ["full"],
+  create_relations: ["full"],
+  add_observations: ["full"],
+  delete_entities: ["full"],
+  delete_observations: ["full"],
+  delete_relations: ["full"],
+  read_graph: ["full"],
+  search_nodes: ["full"],
+  open_nodes: ["full"]
+});
+function isToolInProfile(toolName, profile) {
+  const profiles = TOOL_PROFILES[toolName];
+  if (!profiles) {
+    return profile === "full";
+  }
+  return profiles.includes(profile);
+}
+function resolveToolProfile(opts) {
+  const normalize = (v) => {
+    if (!v) return null;
+    const s = String(v).trim().toLowerCase();
+    if (s === "lite" || s === "team" || s === "full") return s;
+    return null;
+  };
+  return normalize(opts.explicit) ?? normalize(opts.envValue) ?? opts.fallback;
+}
+function describeProfile(profile) {
+  switch (profile) {
+    case "lite":
+      return "lite (core memory + sessions, ~13 tools)";
+    case "team":
+      return "team (lite + agent team tools + dashboard, ~20 tools)";
+    case "full":
+      return "full (all tools including advanced / KG-compat)";
+  }
+}
+
 // src/server.ts
 init_provider2();
 init_memory_manager();
 init_formation();
-var FORMATION_TIMEOUT_MS = 12e3;
+
+// src/server/formation-timeout.ts
+init_esm_shims();
+var DEFAULT_FORMATION_TIMEOUT_MS = 12e3;
+var FORMATION_TIMEOUT_MIN_MS = 1e3;
+var FORMATION_TIMEOUT_MAX_MS = 3e5;
+function parseFormationTimeoutMs(raw) {
+  const value = raw?.trim();
+  if (!value) return DEFAULT_FORMATION_TIMEOUT_MS;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || Number.isNaN(parsed)) {
+    console.warn(
+      `[memorix] MEMORIX_FORMATION_TIMEOUT_MS="${raw}" is invalid (must be a positive integer between ${FORMATION_TIMEOUT_MIN_MS}-${FORMATION_TIMEOUT_MAX_MS}ms). Using default ${DEFAULT_FORMATION_TIMEOUT_MS}ms.`
+    );
+    return DEFAULT_FORMATION_TIMEOUT_MS;
+  }
+  if (parsed < FORMATION_TIMEOUT_MIN_MS) return FORMATION_TIMEOUT_MIN_MS;
+  if (parsed > FORMATION_TIMEOUT_MAX_MS) return FORMATION_TIMEOUT_MAX_MS;
+  return parsed;
+}
+
+// src/server.ts
+var FORMATION_TIMEOUT_MS = parseFormationTimeoutMs(process.env.MEMORIX_FORMATION_TIMEOUT_MS);
+var COMPACT_ON_WRITE_TIMEOUT_MS = 12e3;
 var COMPRESSION_TIMEOUT_MS = 5e3;
 var DEDUP_PER_PAIR_TIMEOUT_MS = 5e3;
 function withTimeout(promise, ms, label) {
@@ -14779,6 +16143,11 @@ function withTimeout(promise, ms, label) {
     })
   ]).finally(() => clearTimeout(timer));
 }
+function formatFormationStageDurations(stageDurationsMs) {
+  const orderedStages = ["extract", "resolve", "evaluate"];
+  const parts = orderedStages.filter((stage) => stageDurationsMs[stage] !== void 0).map((stage) => `${stage}=${stageDurationsMs[stage]}ms`);
+  return parts.join(", ");
+}
 var lastInternalWriteMs = 0;
 var markInternalWrite = () => {
   lastInternalWriteMs = Date.now();
@@ -14793,7 +16162,8 @@ var OBSERVATION_TYPES = [
   "discovery",
   "why-it-exists",
   "decision",
-  "trade-off"
+  "trade-off",
+  "probe"
 ];
 function coerceNumberArray(val) {
   if (Array.isArray(val)) return val.map(Number);
@@ -14870,11 +16240,21 @@ function coerceObjectArray(val) {
   }
   return [];
 }
+function createDeterministicInstanceId(projectId, agentType, agentName) {
+  const digest = createHash4("sha256").update(projectId).update("\n").update(agentType).update("\n").update(agentName ?? "").digest("hex").slice(0, 24);
+  return `auto-${digest}`;
+}
 async function createMemorixServer(cwd, existingServer, sharedTeam, options = {}) {
   const allowUntrackedFallback = options.allowUntrackedFallback ?? true;
   const deferProjectInitUntilBound = options.deferProjectInitUntilBound ?? false;
   const dashboardMode = options.dashboardMode ?? (sharedTeam ? "control-plane" : "standalone");
   const configuredDashboardPort = options.dashboardPort ?? (dashboardMode === "control-plane" ? 3211 : 3210);
+  const toolProfile = resolveToolProfile({
+    explicit: options.toolProfile,
+    envValue: process.env.MEMORIX_MODE,
+    fallback: sharedTeam ? "team" : "lite"
+  });
+  const teamFeaturesEnabled = isToolInProfile("team_manage", toolProfile);
   const detectedProject = detectProject(cwd);
   let rawProject;
   let projectResolved = true;
@@ -14949,6 +16329,9 @@ async function createMemorixServer(cwd, existingServer, sharedTeam, options = {}
     } else {
       console.error(`[memorix] LLM mode: off (set MEMORIX_LLM_API_KEY or OPENAI_API_KEY to enable)`);
     }
+    if (logPrefix === "startup") {
+      console.error(`[memorix] Tool profile: ${describeProfile(toolProfile)}`);
+    }
     if (logPrefix === "startup") {
       console.error(`[memorix] Project: ${project.id} (${project.name})`);
       console.error(`[memorix] Data dir: ${projectDir2}`);
@@ -15009,13 +16392,20 @@ The path should point to a directory containing a .git folder.`
   };
   const server = existingServer ?? new McpServer({
     name: "memorix",
-    version: true ? "1.0.7" : "1.0.1"
+    version: true ? "1.0.9" : "1.0.1"
+  });
+  const originalRegisterTool = server.registerTool.bind(server);
+  server.registerTool = ((name, ...args) => {
+    if (!isToolInProfile(name, toolProfile)) {
+      return void 0;
+    }
+    return originalRegisterTool(name, ...args);
   });
   server.registerTool(
     "memorix_store",
     {
       title: "Store Memory",
-      description: "Store a new observation/memory. Automatically indexed for search. Use type to classify: gotcha (\u{1F534} critical pitfall), decision (\u{1F7E4} architecture choice), problem-solution (\u{1F7E1} bug fix), how-it-works (\u{1F535} explanation), what-changed (\u{1F7E2} change), discovery (\u{1F7E3} insight), why-it-exists (\u{1F7E0} rationale), trade-off (\u2696\uFE0F compromise), session-request (\u{1F3AF} original goal). Stored memories persist across sessions and are shared with other IDEs (Cursor, Windsurf, Claude Code, Codex, Copilot, Kiro, Antigravity, Trae) via the same local data directory.",
+      description: "Store a new observation/memory. Automatically indexed for search. Use type to classify: gotcha ([GOTCHA] critical pitfall), decision ([DECISION] architecture choice), problem-solution ([FIX] bug fix), how-it-works ([INFO] explanation), what-changed ([CHANGE] change), discovery ([DISCOVERY] insight), why-it-exists ([WHY] rationale), trade-off ([TRADEOFF] compromise), session-request ([SESSION] original goal). Stored memories persist across sessions and are shared with other IDEs (Cursor, Windsurf, Claude Code, Codex, Copilot, Kiro, Antigravity, Trae) via the same local data directory.",
       inputSchema: {
         entityName: z2.string().describe('The entity this observation belongs to (e.g., "auth-module", "port-config")'),
         type: z2.enum(OBSERVATION_TYPES).describe("Observation type for classification"),
@@ -15060,6 +16450,19 @@ The path should point to a directory containing a .git folder.`
         let formationResult = null;
         let formationNote = "";
         if (useFormation && !topicKey && !progress) {
+          let currentFormationStage = "setup";
+          const completedFormationStages = {};
+          const formationStartTime = Date.now();
+          const onFormationStageEvent = (event) => {
+            if (event.status === "start") {
+              currentFormationStage = event.stage;
+              return;
+            }
+            currentFormationStage = event.stage;
+            if (event.stageDurationMs !== void 0) {
+              completedFormationStages[event.stage] = event.stageDurationMs;
+            }
+          };
           try {
             const formationConfig = {
               mode: "active",
@@ -15093,7 +16496,8 @@ The path should point to a directory containing a .git folder.`
                   topicKey: o.topicKey
                 };
               },
-              getEntityNames: () => graphManager.getEntityNames()
+              getEntityNames: () => graphManager.getEntityNames(),
+              onStageEvent: onFormationStageEvent
             };
             formationResult = await withTimeout(
               runFormation({
@@ -15108,7 +16512,7 @@ The path should point to a directory containing a .git folder.`
               FORMATION_TIMEOUT_MS,
               "Formation pipeline"
             );
-            const modeIcon = "\u26A1";
+            const modeIcon = "[FAST]";
             formationNote = `
 ${modeIcon} Formation[active]: ${formationResult.evaluation.category} (${formationResult.evaluation.score.toFixed(2)}) | ${formationResult.resolution.action} | ${formationResult.pipeline.durationMs}ms`;
             if (formationResult.extraction.extractedFacts.length > 0) {
@@ -15119,8 +16523,16 @@ ${modeIcon} Formation[active]: ${formationResult.evaluation.category} (${formati
             if (formationResult.extraction.typeCorrected) formationNote += ` | type\u2192${formationResult.type}`;
           } catch (formationErr) {
             const isTimeout = formationErr instanceof Error && formationErr.message.includes("timed out");
+            const elapsedMs = Date.now() - formationStartTime;
+            const stageSummary = formatFormationStageDurations(completedFormationStages);
+            console.error(
+              `[memorix] Formation ${isTimeout ? "timed out" : "failed"} in memorix_store after ${elapsedMs}ms/${FORMATION_TIMEOUT_MS}ms at stage ${currentFormationStage}${stageSummary ? ` | completed: ${stageSummary}` : ""}`
+            );
+            if (!isTimeout && formationErr instanceof Error) {
+              console.error(`[memorix] Formation error: ${formationErr.message}`);
+            }
             formationNote = `
-\u26A0\uFE0F Formation ${isTimeout ? "timed out" : "failed"} \u2014 storing base observation without enrichment`;
+[WARN] Formation ${isTimeout ? "timed out" : "failed"} \u2014 storing base observation without enrichment`;
           }
         }
         if (useFormation && formationResult && formationResult.resolution.action !== "new") {
@@ -15146,7 +16558,7 @@ ${modeIcon} Formation[active]: ${formationResult.evaluation.category} (${formati
               return {
                 content: [{
                   type: "text",
-                  text: `\u{1F504} Formation MERGE: merged into #${targetId} (${reason})${formationNote}`
+                  text: `[UPDATED] Formation MERGE: merged into #${targetId} (${reason})${formationNote}`
                 }]
               };
             }
@@ -15171,7 +16583,7 @@ ${modeIcon} Formation[active]: ${formationResult.evaluation.category} (${formati
               return {
                 content: [{
                   type: "text",
-                  text: `\u{1F504} Formation EVOLVE: evolved #${targetId} (${reason})${formationNote}`
+                  text: `[UPDATED] Formation EVOLVE: evolved #${targetId} (${reason})${formationNote}`
                 }]
               };
             }
@@ -15179,7 +16591,7 @@ ${modeIcon} Formation[active]: ${formationResult.evaluation.category} (${formati
             return {
               content: [{
                 type: "text",
-                text: `\u23ED\uFE0F Formation DISCARD: ${reason}${formationNote}`
+                text: `[SKIP] Formation DISCARD: ${reason}${formationNote}`
               }]
             };
           }
@@ -15210,7 +16622,7 @@ ${modeIcon} Formation[active]: ${formationResult.evaluation.category} (${formati
                   { title, narrative, facts: safeFacts ?? [] },
                   existingMemories
                 ),
-                FORMATION_TIMEOUT_MS,
+                COMPACT_ON_WRITE_TIMEOUT_MS,
                 "Compact-on-write"
               );
               if (decision.action === "UPDATE" && decision.targetId) {
@@ -15231,7 +16643,7 @@ ${modeIcon} Formation[active]: ${formationResult.evaluation.category} (${formati
                     sourceDetail: "explicit",
                     createdByAgentId: currentAgentId
                   });
-                  compactAction = `\u{1F504} Compact UPDATE: merged into #${decision.targetId} (${decision.reason})`;
+                  compactAction = `[UPDATED] Compact UPDATE: merged into #${decision.targetId} (${decision.reason})`;
                   compactMerged = true;
                   return {
                     content: [{
@@ -15245,7 +16657,7 @@ Mode: ${decision.usedLLM ? "LLM" : "heuristic"}`
                 return {
                   content: [{
                     type: "text",
-                    text: `\u23ED\uFE0F Compact SKIP: ${decision.reason}
+                    text: `[SKIP] Compact SKIP: ${decision.reason}
 Existing memory #${decision.targetId} already covers this.
 Mode: ${decision.usedLLM ? "LLM" : "heuristic"}`
                   }]
@@ -15316,7 +16728,7 @@ Mode: ${decision.usedLLM ? "LLM" : "heuristic"}`
           const attrCheck = await checkProjectAttribution(entityName, project.id, getAllObservations());
           if (attrCheck.suspicious) {
             attributionWarning = `
-\u26A0\uFE0F Attribution notice: entity "${entityName}" has 0 observations in "${project.id}" but ${attrCheck.count} in "${attrCheck.knownIn}" (confidence: ${attrCheck.confidence}). Verify the correct project is bound before storing.`;
+[WARN] Attribution notice: entity "${entityName}" has 0 observations in "${project.id}" but ${attrCheck.count} in "${attrCheck.knownIn}" (confidence: ${attrCheck.confidence}). Verify the correct project is bound before storing.`;
           }
         } catch {
         }
@@ -15354,7 +16766,7 @@ Mode: ${decision.usedLLM ? "LLM" : "heuristic"}`
         if (upserted) enrichmentParts.push(`topic upserted (rev ${obs.revisionCount ?? 1})`);
         const enrichment = enrichmentParts.length > 0 ? `
 Auto-enriched: ${enrichmentParts.join(", ")}` : "";
-        const action = upserted ? "\u{1F504} Updated" : "\u2705 Stored";
+        const action = upserted ? "[UPDATED] Updated" : "[OK] Stored";
         if (!useFormation && !topicKey && !progress) {
           const shadowFormation = async () => {
             let oldCompactDecision = null;
@@ -15583,13 +16995,13 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
       const result = await resolveObservations2(safeIds, status ?? "resolved");
       const parts = [];
       if (result.resolved.length > 0) {
-        parts.push(`\u2705 Resolved ${result.resolved.length} observation(s): #${result.resolved.join(", #")}`);
+        parts.push(`[OK] Resolved ${result.resolved.length} observation(s): #${result.resolved.join(", #")}`);
       }
       if (result.notFound.length > 0) {
-        parts.push(`\u26A0\uFE0F Not found: #${result.notFound.join(", #")}`);
+        parts.push(`[WARN] Not found: #${result.notFound.join(", #")}`);
       }
       parts.push('\nResolved memories are hidden from default search. Use status="all" to include them.');
-      parts.push('\u{1F4CA} Run `memorix_retention` with `action: "report"` to check remaining cleanup status.');
+      parts.push('[STATS] Run `memorix_retention` with `action: "report"` to check remaining cleanup status.');
       return {
         content: [{ type: "text", text: parts.join("\n") }]
       };
@@ -15642,7 +17054,7 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
           const attrCheck = await checkProjectAttribution(entityName, project.id, getAllObservations());
           if (attrCheck.suspicious) {
             reasoningAttributionWarning = `
-\u26A0\uFE0F Attribution notice: entity "${entityName}" has 0 observations in "${project.id}" but ${attrCheck.count} in "${attrCheck.knownIn}" (confidence: ${attrCheck.confidence}). Verify the correct project is bound before storing.`;
+[WARN] Attribution notice: entity "${entityName}" has 0 observations in "${project.id}" but ${attrCheck.count} in "${attrCheck.knownIn}" (confidence: ${attrCheck.confidence}). Verify the correct project is bound before storing.`;
           }
         } catch {
         }
@@ -15663,12 +17075,12 @@ _Search mode: ${getLastSearchMode2(project.id)}_`;
           createdByAgentId: currentAgentId
         });
         await graphManager.addObservations([
-          { entityName, contents: [`[#${obs.id}] \u{1F9E0} ${decision}`] }
+          { entityName, contents: [`[#${obs.id}] [REASONING] ${decision}`] }
         ]);
         return {
           content: [{
             type: "text",
-            text: `\u{1F9E0} Reasoning trace stored #${obs.id}: "${decision}"
+            text: `[REASONING] Reasoning trace stored #${obs.id}: "${decision}"
 Entity: ${entityName} | ${facts.length} facts | ${obs.tokens} tokens${reasoningAttributionWarning}`
           }]
         };
@@ -15705,7 +17117,7 @@ Entity: ${entityName} | ${facts.length} facts | ${obs.tokens} tokens${reasoningA
         return {
           content: [{
             type: "text",
-            text: `\u2705 No suspicious observations found in project "${project.id}" (threshold: ${minCount}).`
+            text: `[OK] No suspicious observations found in project "${project.id}" (threshold: ${minCount}).`
           }]
         };
       }
@@ -15765,7 +17177,7 @@ Entity: ${entityName} | ${facts.length} facts | ${obs.tokens} tokens${reasoningA
         };
       }
       return {
-        content: [{ type: "text", text: `\u{1F9E0} Reasoning Traces:
+        content: [{ type: "text", text: `[REASONING] Reasoning Traces:
 ${result.formatted}` }]
       };
     }
@@ -15790,7 +17202,7 @@ ${result.formatted}` }]
         return {
           content: [{
             type: "text",
-            text: "\u26A0\uFE0F LLM not configured. Set MEMORIX_LLM_API_KEY or OPENAI_API_KEY to enable intelligent dedup.\n\nTip: Use memorix_consolidate for basic similarity-based merging without LLM."
+            text: "[WARN] LLM not configured. Set MEMORIX_LLM_API_KEY or OPENAI_API_KEY to enable intelligent dedup.\n\nTip: Use memorix_consolidate for basic similarity-based merging without LLM."
           }]
         };
       }
@@ -15825,29 +17237,29 @@ ${result.formatted}` }]
                 [{ id: older.id, title: older.title, narrative: older.narrative, facts: older.facts.join("\n") }]
               );
               if (decision && decision.action === "UPDATE" && decision.targetId) {
-                actions.push(`\u{1F504} #${older.id} "${older.title}" \u2192 superseded by #${newer.id} (${decision.reason})${decision.usedLLM ? " [LLM]" : " [heuristic]"}`);
+                actions.push(`[UPDATED] #${older.id} "${older.title}" \u2192 superseded by #${newer.id} (${decision.reason})${decision.usedLLM ? " [LLM]" : " [heuristic]"}`);
                 toResolve.push(older.id);
               } else if (decision && decision.action === "NONE") {
-                actions.push(`\u{1F5D1}\uFE0F #${newer.id} "${newer.title}" \u2192 redundant (${decision.reason})${decision.usedLLM ? " [LLM]" : " [heuristic]"}`);
+                actions.push(`[DELETE] #${newer.id} "${newer.title}" \u2192 redundant (${decision.reason})${decision.usedLLM ? " [LLM]" : " [heuristic]"}`);
                 toResolve.push(newer.id);
               } else if (decision && decision.action === "DELETE") {
-                actions.push(`\u274C #${decision.targetId ?? older.id} \u2192 outdated (${decision.reason})${decision.usedLLM ? " [LLM]" : " [heuristic]"}`);
+                actions.push(`[ERROR] #${decision.targetId ?? older.id} \u2192 outdated (${decision.reason})${decision.usedLLM ? " [LLM]" : " [heuristic]"}`);
                 toResolve.push(decision.targetId ?? older.id);
               }
             } catch (dedupErr) {
-              actions.push(`\u26A0\uFE0F comparison failed: ${dedupErr?.message ?? dedupErr}`);
+              actions.push(`[WARN] comparison failed: ${dedupErr?.message ?? dedupErr}`);
             }
           }
         }
       }
       if (actions.length === 0) {
-        return { content: [{ type: "text", text: `\u2705 Scanned ${candidates.length} memories across ${byEntity.size} entities \u2014 no duplicates found.` }] };
+        return { content: [{ type: "text", text: `[OK] Scanned ${candidates.length} memories across ${byEntity.size} entities \u2014 no duplicates found.` }] };
       }
       if (dryRun) {
         return {
           content: [{
             type: "text",
-            text: `\u{1F50D} DRY RUN \u2014 ${actions.length} action(s) found:
+            text: `[SEARCH] DRY RUN \u2014 ${actions.length} action(s) found:
 
 ${actions.join("\n")}
 
@@ -15860,7 +17272,7 @@ Run with dryRun=false to apply.`
       return {
         content: [{
           type: "text",
-          text: `\u{1F9F9} Deduplicated: resolved ${unique.length} memory(ies)
+          text: `[CLEANUP] Deduplicated: resolved ${unique.length} memory(ies)
 
 ${actions.join("\n")}`
         }]
@@ -15976,11 +17388,11 @@ ${actions.join("\n")}`
         const result = await archiveExpired2(projectDir2, void 0, accessMap);
         if (result.archived === 0) {
           return {
-            content: [{ type: "text", text: "\u2705 No expired observations to archive. All memories are within their retention period." }]
+            content: [{ type: "text", text: "[OK] No expired observations to archive. All memories are within their retention period." }]
           };
         }
         return {
-          content: [{ type: "text", text: `\u{1F5C4}\uFE0F Archived ${result.archived} expired observations (status set to 'archived' in-place)
+          content: [{ type: "text", text: `[ARCHIVED] Archived ${result.archived} expired observations (status set to 'archived' in-place)
 ${result.remaining} active observations remaining.
 
 Archived memories are hidden from default search but can be found with status: "all".` }]
@@ -16015,7 +17427,7 @@ Archived memories are hidden from default search but can be found with status: "
         const staleDocs = docs.filter((d) => getRetentionZone2(d) === "stale");
         if (staleDocs.length === 0) {
           return {
-            content: [{ type: "text", text: "\u2705 No stale observations. All active memories are within 50% of their retention period." }]
+            content: [{ type: "text", text: "[OK] No stale observations. All active memories are within 50% of their retention period." }]
           };
         }
         const staleLines = [
@@ -16033,7 +17445,7 @@ Archived memories are hidden from default search but can be found with status: "
           );
         }
         staleLines.push("");
-        staleLines.push("> \u{1F4A1} Stale = past 50% of effective retention. Review or access to keep; otherwise will become archive candidates.");
+        staleLines.push("> [TIP] Stale = past 50% of effective retention. Review or access to keep; otherwise will become archive candidates.");
         const staleIds = staleDocs.map((d) => d.observationId);
         staleLines.push("");
         staleLines.push("### Suggested Actions");
@@ -16085,11 +17497,11 @@ Archived memories are hidden from default search but can be found with status: "
         const candidateIds = candidates.map((c) => c.observationId);
         lines.push("");
         lines.push(`Candidate IDs: [${candidateIds.slice(0, 20).join(", ")}]${candidateIds.length > 20 ? ` \u2026 (${candidateIds.length} total)` : ""}`);
-        lines.push(`> \u{1F4A1} Use \`memorix_retention\` with \`action: "archive"\` to move all, or \`memorix_resolve\` with specific IDs.`);
+        lines.push(`> [TIP] Use \`memorix_retention\` with \`action: "archive"\` to move all, or \`memorix_resolve\` with specific IDs.`);
         lines.push("");
       }
       if (summary.stale > 0) {
-        lines.push(`> \u{1F4CB} ${summary.stale} stale observation(s) \u2014 use \`memorix_retention\` with \`action: "stale"\` for full details.`);
+        lines.push(`> [TASK] ${summary.stale} stale observation(s) \u2014 use \`memorix_retention\` with \`action: "stale"\` for full details.`);
         lines.push("");
       }
       lines.push(`### Top 5 Most Relevant`);
@@ -16120,12 +17532,12 @@ Archived memories are hidden from default search but can be found with status: "
         return {
           content: [{
             type: "text",
-            text: "\u{1F4CA} Formation Pipeline: No metrics collected yet.\nStore some observations to start collecting runtime data."
+            text: "[STATS] Formation Pipeline: No metrics collected yet.\nStore some observations to start collecting runtime data."
           }]
         };
       }
       const lines = [
-        "\u{1F4CA} **Formation Pipeline Metrics**",
+        "[STATS] **Formation Pipeline Metrics**",
         "",
         `**Total observations processed:** ${summary.total}`,
         `**Average value score:** ${summary.avgValueScore.toFixed(3)}`,
@@ -16141,7 +17553,7 @@ Archived memories are hidden from default search but can be found with status: "
       ];
       for (const [cat, count2] of Object.entries(summary.categoryBreakdown)) {
         const pct = (count2 / summary.total * 100).toFixed(1);
-        const icon = cat === "core" ? "\u{1F7E2}" : cat === "contextual" ? "\u{1F7E1}" : "\u{1F534}";
+        const icon = cat === "core" ? "[CHANGE]" : cat === "contextual" ? "[FIX]" : "[GOTCHA]";
         lines.push(`- ${icon} **${cat}:** ${count2} (${pct}%)`);
       }
       lines.push("", "### Resolution Actions");
@@ -16183,7 +17595,7 @@ Archived memories are hidden from default search but can be found with status: "
       };
     }
   );
-  let enableKG = false;
+  let enableKG = isToolInProfile("create_entities", toolProfile);
   try {
     const { homedir: homedir21 } = await import("os");
     const { join: join23 } = await import("path");
@@ -16495,7 +17907,7 @@ Archived memories are hidden from default search but can be found with status: "
           lines2.push("- No skills found");
         }
         if (scan.skillConflicts.length > 0) {
-          lines2.push("", `### \u26A0\uFE0F Skill Name Conflicts`);
+          lines2.push("", `### [WARN] Skill Name Conflicts`);
           for (const c of scan.skillConflicts) {
             lines2.push(`- **${c.name}**: kept from ${c.kept.sourceAgent}, duplicate in ${c.skipped.sourceAgent}`);
           }
@@ -16641,9 +18053,9 @@ ${skill.content}` }]
         if (write && target) {
           const path18 = engine.writeSkill(sk, target);
           if (path18) {
-            lines.push(`- \u2705 **Written**: \`${path18}\``);
+            lines.push(`- [OK] **Written**: \`${path18}\``);
           } else {
-            lines.push(`- \u274C Failed to write`);
+            lines.push(`- [ERROR] Failed to write`);
           }
         }
         lines.push("");
@@ -16700,7 +18112,7 @@ ${skill.content}` }]
         if (!deleted) {
           return { content: [{ type: "text", text: `Mini-skill #${skillId} not found.` }], isError: true };
         }
-        return { content: [{ type: "text", text: `\u2705 Deleted mini-skill #${skillId}.` }] };
+        return { content: [{ type: "text", text: `[OK] Deleted mini-skill #${skillId}.` }] };
       }
       if (!observationIds || observationIds.length === 0) {
         return { content: [{ type: "text", text: "Error: `observationIds` is required for promote action. Use `memorix_search` to find observation IDs." }], isError: true };
@@ -16717,7 +18129,7 @@ ${skill.content}` }]
       }
       const skill = await promoteToMiniSkill2(projectDir2, project.id, matched, { trigger, instruction, tags });
       const lines = [
-        `\u2705 Created mini-skill #${skill.id}`,
+        `[OK] Created mini-skill #${skill.id}`,
         "",
         `**${skill.title}**`,
         `**Do**: ${skill.instruction}`,
@@ -16748,7 +18160,7 @@ ${skill.content}` }]
       if (action === "preview") {
         const clusters = await findConsolidationCandidates2(projectDir2, project.id, { threshold: safeThreshold });
         if (clusters.length === 0) {
-          return { content: [{ type: "text", text: "\u2705 No consolidation candidates found. Your memories are already clean!" }] };
+          return { content: [{ type: "text", text: "[OK] No consolidation candidates found. Your memories are already clean!" }] };
         }
         const lines2 = [`## Consolidation Preview`, `Found **${clusters.length}** clusters to merge:`, ""];
         for (let i = 0; i < clusters.length; i++) {
@@ -16764,7 +18176,7 @@ ${skill.content}` }]
       }
       const result = await executeConsolidation2(projectDir2, project.id, { threshold: safeThreshold });
       if (result.clustersFound === 0) {
-        return { content: [{ type: "text", text: "\u2705 No consolidation needed. Memories are already clean!" }] };
+        return { content: [{ type: "text", text: "[OK] No consolidation needed. Memories are already clean!" }] };
       }
       const lines = [
         `## Consolidation Complete`,
@@ -16783,18 +18195,20 @@ ${skill.content}` }]
     "memorix_session_start",
     {
       title: "Start Session",
-      description: "Start a new coding session. Returns context from previous sessions so you can resume work seamlessly. Call this at the beginning of a session to track activity and get injected context. Any previous active session for this project will be auto-closed.\n\nIMPORTANT for HTTP/control-plane mode: pass `projectRoot` with the absolute path to your workspace root (e.g., the directory open in your IDE). Memorix uses this to detect the git project and bind this session to the correct project context. Without it, project-scoped tools will be disabled.",
+      description: "Start a new coding session. Returns context from previous sessions so you can resume work seamlessly. Call this at the beginning of a session to track activity and get injected context. Any previous active session for this project will be auto-closed. By default this is lightweight: it binds the project, opens a session, and injects context only. Team identity is opt-in via `joinTeam: true` or a separate `team_manage` join call.\n\nIMPORTANT for HTTP/control-plane mode: pass `projectRoot` with the absolute path to your workspace root (e.g., the directory open in your IDE). Memorix uses this to detect the git project and bind this session to the correct project context. Without it, project-scoped tools will be disabled.",
       inputSchema: {
         sessionId: z2.string().optional().describe("Custom session ID (auto-generated if omitted)"),
         agent: z2.string().optional().describe('Agent/IDE name (e.g., "cursor", "windsurf", "claude-code")'),
-        agentType: z2.string().optional().describe('Agent type for durable identity (e.g., "windsurf", "cursor"). Defaults to agent if omitted.'),
-        instanceId: z2.string().optional().describe("Stable instance ID for durable identity across restarts. Auto-generated if omitted."),
+        agentType: z2.string().optional().describe('Agent type used for optional Agent Team identity mapping (e.g., "windsurf", "cursor").'),
+        instanceId: z2.string().optional().describe("Stable instance ID for optional Agent Team identity across restarts. If omitted with joinTeam=true, Memorix derives a deterministic fallback from the project and agent identity."),
+        joinTeam: z2.boolean().optional().describe("If true, also join the autonomous agent team for this session. Defaults to false."),
+        role: z2.string().optional().describe("Explicit role override used only when joinTeam=true."),
         projectRoot: z2.string().optional().describe(
-          "Absolute path to the workspace/project root directory (e.g., the folder open in your IDE). Memorix will detect the git project from this path and bind this session to it. Required for HTTP transport when multiple projects are open simultaneously."
+          "Absolute path to the workspace/project root directory (e.g., the folder open in your IDE). Memorix will detect the git project from this path and bind this session to it. Required for HTTP transport when multiple projects are open simultaneously or when rebinding an existing control-plane session."
         )
       }
     },
-    async ({ sessionId, agent, agentType, instanceId, projectRoot: explicitRoot }) => {
+    async ({ sessionId, agent, agentType, instanceId, joinTeam, role, projectRoot: explicitRoot }) => {
       currentAgentId = void 0;
       if (explicitRoot && typeof explicitRoot === "string") {
         let bound = await switchProject(explicitRoot);
@@ -16841,18 +18255,27 @@ Ensure the path points to a directory containing a .git folder (or a subdirector
       const { startSession: startSession2 } = await Promise.resolve().then(() => (init_session(), session_exports));
       const result = await startSession2(projectDir2, project.id, { sessionId, agent });
       const llmStatus = isLLMEnabled() ? `LLM enhanced mode: ${getLLMConfig()?.provider}/${getLLMConfig()?.model} (fact extraction + auto-dedup active)` : "LLM mode: off (set MEMORIX_LLM_API_KEY to enable enhanced memory quality)";
+      const shouldJoinTeam = !!joinTeam;
       let registeredAgent = null;
       let watermarkInfo = "";
       let rescueInfo = "";
+      let teamJoinNotice = "";
       try {
-        if (typeof teamStore !== "undefined" && (agent || agentType)) {
+        if (!teamFeaturesEnabled && shouldJoinTeam) {
+          teamJoinNotice = "Team join skipped: the current tool profile does not expose Agent Team tools.";
+        } else if (shouldJoinTeam && typeof teamStore !== "undefined" && (agent || agentType)) {
           const { AGENT_TYPE_ROLE_MAP: AGENT_TYPE_ROLE_MAP2 } = await Promise.resolve().then(() => (init_team_store(), team_store_exports));
           const resolvedAgentType = agentType || agent || "unknown";
-          const resolvedRole = (resolvedAgentType ? AGENT_TYPE_ROLE_MAP2[resolvedAgentType] : void 0) || "engineer";
+          const resolvedRole = role || (resolvedAgentType ? AGENT_TYPE_ROLE_MAP2[resolvedAgentType] : void 0) || "engineer";
+          const resolvedInstanceId = instanceId || createDeterministicInstanceId(
+            project.id,
+            resolvedAgentType,
+            agent || agentType || void 0
+          );
           registeredAgent = teamStore.registerAgent({
             projectId: project.id,
             agentType: resolvedAgentType,
-            instanceId: instanceId || void 0,
+            instanceId: resolvedInstanceId,
             name: agent || agentType || void 0,
             role: resolvedRole
           });
@@ -16866,32 +18289,36 @@ Ensure the path points to a directory containing a .git folder (or a subdirector
           ));
           const wm = computeWatermark2(lastSeen, currentGen, projectObs.length);
           if (wm.newObservationCount > 0) {
-            watermarkInfo = `\u{1F4CA} ${wm.newObservationCount} new observation(s) in this project since your last session.`;
+            watermarkInfo = `[STATS] ${wm.newObservationCount} new observation(s) in this project since your last session.`;
           }
           teamStore.updateWatermark(registeredAgent.agent_id, currentGen);
           const STALE_TTL_MS = 5 * 60 * 1e3;
           const rescuedAgentIds = teamStore.detectAndMarkStale(project.id, STALE_TTL_MS);
           if (rescuedAgentIds.length > 0) {
-            rescueInfo = `\u{1F691} ${rescuedAgentIds.length} stale agent(s) detected and rescued.`;
+            rescueInfo = `[RESCUE] ${rescuedAgentIds.length} stale agent(s) detected and rescued.`;
           }
           const availableTasks = teamStore.listTasks(project.id, { available: true });
           if (availableTasks.length > 0) {
             rescueInfo += rescueInfo ? "\n" : "";
-            rescueInfo += `\u{1F4CB} ${availableTasks.length} task(s) available to claim. Use memorix_poll for details.`;
+            rescueInfo += `[TASK] ${availableTasks.length} task(s) available to claim. Use memorix_poll for details.`;
           }
+        } else if (shouldJoinTeam) {
+          teamJoinNotice = "Team join skipped: pass `agent` or `agentType` to create an Agent Team identity.";
         }
       } catch {
       }
       const lines = [
-        `\u2705 Session started: ${result.session.id}`,
+        `[OK] Session started: ${result.session.id}`,
         `Project: ${project.name} (${project.id})`,
         result.session.agent ? `Agent: ${result.session.agent}` : "",
         registeredAgent ? `Agent ID: ${registeredAgent.agent_id} (instance: ${registeredAgent.instance_id})` : "",
+        !registeredAgent ? "Team identity: not joined (memory/session context only)" : "",
         llmStatus,
-        watermarkInfo,
-        rescueInfo,
+        teamJoinNotice,
+        registeredAgent ? watermarkInfo : "",
+        registeredAgent ? rescueInfo : "",
         "",
-        "\u{1F4A1} Tips: Use `memorix_resolve` to mark completed tasks. Use `progress` param in `memorix_store` for task tracking. Use `topicKey` to prevent duplicate memories.",
+        "[TIP] Tips: Use `memorix_resolve` to mark completed tasks. Use `progress` param in `memorix_store` for task tracking. Use `topicKey` to prevent duplicate memories.",
         ""
       ];
       try {
@@ -16931,27 +18358,27 @@ ${s.instruction}`.toLowerCase();
       } catch {
       }
       if (result.previousContext) {
-        lines.push("---", "\u{1F4CB} **Context from previous sessions:**", "", result.previousContext);
+        lines.push("---", "[TASK] **Context from previous sessions:**", "", result.previousContext);
       } else {
         lines.push("No previous session context found. This appears to be a fresh project.");
       }
       try {
-        if (typeof teamStore !== "undefined") {
+        if (registeredAgent && teamFeaturesEnabled && typeof teamStore !== "undefined") {
           const activeAgents = teamStore.listAgents(project.id, { status: "active" });
           if (activeAgents.length > 0) {
-            lines.push("", "---", "\u{1F465} **Team Status:**");
+            lines.push("", "---", "[TEAM] **Team Status:**");
             for (const a of activeAgents) {
-              lines.push(`- \u{1F7E2} ${a.name}${a.role ? ` (${a.role})` : ""}`);
+              lines.push(`- [CHANGE] ${a.name}${a.role ? ` (${a.role})` : ""}`);
             }
             const locks = teamStore.listLocks(project.id);
             if (locks.length > 0) {
-              lines.push("", "\u{1F512} **Locked files:**");
+              lines.push("", "[LOCK] **Locked files:**");
               for (const l of locks) {
                 const owner = teamStore.getAgent(l.locked_by);
                 lines.push(`- ${l.file} \u2014 ${owner?.name ?? l.locked_by.slice(0, 8)}`);
               }
             }
-            lines.push("", "\u{1F4A1} Use `team_manage` to register, `team_message` to check inbox, `team_task` to see tasks.");
+            lines.push("", "[TIP] Use `team_manage` to register, `team_message` to check inbox, `team_task` to see tasks.");
           }
         }
       } catch {
@@ -16965,7 +18392,7 @@ ${s.instruction}`.toLowerCase();
     "memorix_session_end",
     {
       title: "End Session",
-      description: "End a coding session with a structured summary. This summary will be injected into the next session so the next agent can resume work seamlessly.\n\nRecommended summary format:\n## Goal\n[What we were working on]\n\n## Discoveries\n- [Technical findings, gotchas, learnings]\n\n## Accomplished\n- \u2705 [Completed tasks]\n- \u{1F532} [Pending for next session]\n\n## Relevant Files\n- path/to/file \u2014 [what changed]",
+      description: "End a coding session with a structured summary. This summary will be injected into the next session so the next agent can resume work seamlessly.\n\nRecommended summary format:\n## Goal\n[What we were working on]\n\n## Discoveries\n- [Technical findings, gotchas, learnings]\n\n## Accomplished\n- [OK] [Completed tasks]\n- [PENDING] [Pending for next session]\n\n## Relevant Files\n- path/to/file \u2014 [what changed]",
       inputSchema: {
         sessionId: z2.string().describe("Session ID to close (from memorix_session_start)"),
         summary: z2.string().optional().describe("Structured session summary (Goal/Discoveries/Accomplished/Files format)")
@@ -16983,7 +18410,7 @@ ${s.instruction}`.toLowerCase();
       return {
         content: [{
           type: "text",
-          text: `\u2705 Session "${sessionId}" completed.
+          text: `[OK] Session "${sessionId}" completed.
 Duration: ${session.startedAt} \u2192 ${session.endedAt}
 ${summary ? "Summary saved for next session context injection." : "No summary provided \u2014 consider adding one for better cross-session context."}`
         }]
@@ -17056,7 +18483,7 @@ ${json}
           }]
         };
       }
-      if (!jsonStr) return { content: [{ type: "text", text: "\u274C data is required for import" }], isError: true };
+      if (!jsonStr) return { content: [{ type: "text", text: "[ERROR] data is required for import" }], isError: true };
       const { importFromJson: importFromJson2 } = await Promise.resolve().then(() => (init_export_import(), export_import_exports));
       let parsed;
       try {
@@ -17188,9 +18615,7 @@ ${json}
           }
         }
         console.error(`[memorix] Dashboard staticDir: ${staticDir}`);
-        startDashboard2(projectDir2, portNum, staticDir, project.id, project.name, false, {
-          teamStore
-        }, project.rootPath, projectResolved).then(() => {
+        startDashboard2(projectDir2, portNum, staticDir, project.id, project.name, false, void 0, project.rootPath, projectResolved).then(() => {
           dashboardRunning = true;
         }).catch((err) => {
           console.error("[memorix] Dashboard error:", err);
@@ -17240,16 +18665,20 @@ ${json}
       }
     }
   );
-  const { initTeamStore: initTeamStore2 } = await Promise.resolve().then(() => (init_team_store(), team_store_exports));
   let teamStore;
-  if (sharedTeam?.teamStore) {
-    teamStore = sharedTeam.teamStore;
-  } else {
-    teamStore = await initTeamStore2(projectDir2);
-  }
-  if (!teamStore.getEventBus()) {
-    const { TeamEventBus: TeamEventBus2 } = await Promise.resolve().then(() => (init_event_bus(), event_bus_exports));
-    teamStore.setEventBus(new TeamEventBus2());
+  let initTeamStoreForProject;
+  if (teamFeaturesEnabled) {
+    const { initTeamStore: initTeamStore2 } = await Promise.resolve().then(() => (init_team_store(), team_store_exports));
+    initTeamStoreForProject = initTeamStore2;
+    if (sharedTeam?.teamStore) {
+      teamStore = sharedTeam.teamStore;
+    } else {
+      teamStore = await initTeamStore2(projectDir2);
+    }
+    if (!teamStore.getEventBus()) {
+      const { TeamEventBus: TeamEventBus2 } = await Promise.resolve().then(() => (init_event_bus(), event_bus_exports));
+      teamStore.setEventBus(new TeamEventBus2());
+    }
   }
   server.registerTool(
     "team_manage",
@@ -17284,13 +18713,15 @@ ${json}
           role: resolvedRole,
           capabilities: capabilities ? coerceStringArray(capabilities) : void 0
         });
+        currentAgentId = agent.agent_id;
         const caps = agent.capabilities ? JSON.parse(agent.capabilities) : [];
         return {
           content: [{
             type: "text",
-            text: `Joined team as "${agent.name}" (ID: ${agent.agent_id})
+            text: `Joined Agent Team as "${agent.name}" (ID: ${agent.agent_id})
 Instance ID: ${agent.instance_id}
 Role: ${agent.role}
+This session now attributes Agent Team activity to that identity.
 Active agents: ${teamStore.getActiveCount(project.id)}`
           }]
         };
@@ -17298,6 +18729,7 @@ Active agents: ${teamStore.getActiveCount(project.id)}`
       if (action === "leave") {
         if (!agentId) return { content: [{ type: "text", text: "agentId is required for leave" }], isError: true };
         const left = teamStore.leaveAgent(agentId);
+        if (currentAgentId === agentId) currentAgentId = void 0;
         if (!left) return { content: [{ type: "text", text: "Agent not found" }] };
         const releasedLocks = teamStore.releaseAllLocks(agentId);
         const releasedTasks = teamStore.releaseTasksByAgent(agentId);
@@ -17321,7 +18753,7 @@ Active agents: ${teamStore.getActiveCount(project.id)}`
         const lines = occupancy2.map(({ role: role2, activeAgents, vacant }) => {
           const agentTypes = JSON.parse(role2.preferred_agent_types);
           const agentNames = activeAgents.map((a) => a.name).join(", ") || "vacant";
-          return `${role2.label} (${role2.role_id.split(":").pop()}) \u2014 ${activeAgents.length}/${role2.max_concurrent} filled, ${vacant} vacant
+          return `${role2.label} (${role2.role_id.split(":").pop()}) - ${activeAgents.length}/${role2.max_concurrent} filled, ${vacant} vacant
   Agents: ${agentNames}
   Preferred types: ${agentTypes.join(", ") || "any"}${role2.description ? "\n  " + role2.description : ""}`;
         });
@@ -17353,11 +18785,11 @@ ${lines.join("\n\n")}` }] };
       }
       const roleLines = occupancy.map(({ role: role2, activeAgents, vacant }) => {
         const agentNames = activeAgents.map((a) => a.name).join(", ") || "vacant";
-        return `${role2.label}: ${activeAgents.length}/${role2.max_concurrent} \u2014 ${agentNames}${vacant > 0 ? ` (${vacant} slot${vacant > 1 ? "s" : ""} open)` : ""}`;
+        return `${role2.label}: ${activeAgents.length}/${role2.max_concurrent} - ${agentNames}${vacant > 0 ? ` (${vacant} slot${vacant > 1 ? "s" : ""} open)` : ""}`;
       });
       const agentLines = agents.map((a) => {
         const caps = a.capabilities ? JSON.parse(a.capabilities) : [];
-        return `${a.status === "active" ? "\u25CF" : "\u25CB"} ${a.name} (${a.agent_id.slice(0, 8)}\u2026) \u2014 ${a.role ?? "no role"} [${caps.join(", ") || "-"}]`;
+        return `${a.status === "active" ? "[active]" : "[inactive]"} ${a.name} (${a.agent_id.slice(0, 8)}) - ${a.role ?? "no role"} [${caps.join(", ") || "-"}]`;
       });
       return {
         content: [{
@@ -17386,10 +18818,10 @@ ${agentLines.join("\n")}`
     },
     async ({ action, file, agentId }) => {
       if (action === "lock") {
-        if (!file || !agentId) return { content: [{ type: "text", text: "\u274C file and agentId are required for lock" }], isError: true };
+        if (!file || !agentId) return { content: [{ type: "text", text: "[ERROR] file and agentId are required for lock" }], isError: true };
         const agent = teamStore.getAgent(agentId);
         if (!agent || agent.status !== "active") {
-          return { content: [{ type: "text", text: `\u274C Unknown or inactive agent: ${agentId.slice(0, 8)}\u2026` }], isError: true };
+          return { content: [{ type: "text", text: `[ERROR] Unknown or inactive agent: ${agentId.slice(0, 8)}\u2026` }], isError: true };
         }
         const result = teamStore.acquireLock(project.id, file, agentId);
         if (result.success) return { content: [{ type: "text", text: `Locked: ${file}` }] };
@@ -17397,7 +18829,7 @@ ${agentLines.join("\n")}`
         return { content: [{ type: "text", text: `Denied \u2014 locked by ${owner?.name ?? result.lockedBy.slice(0, 8)}` }], isError: true };
       }
       if (action === "unlock") {
-        if (!file || !agentId) return { content: [{ type: "text", text: "\u274C file and agentId are required for unlock" }], isError: true };
+        if (!file || !agentId) return { content: [{ type: "text", text: "[ERROR] file and agentId are required for unlock" }], isError: true };
         const released = teamStore.releaseLock(project.id, file, agentId);
         return { content: [{ type: "text", text: released ? `Unlocked: ${file}` : `Cannot unlock: not owner or not locked` }] };
       }
@@ -17439,7 +18871,7 @@ ${lines.join("\n")}` }] };
     async ({ action, description: desc, deps, taskId, agentId, result, status, available, metadata, requiredRole, preferredRole }) => {
       try {
         if (action === "create") {
-          if (!desc) return { content: [{ type: "text", text: "\u274C description is required for create" }], isError: true };
+          if (!desc) return { content: [{ type: "text", text: "[ERROR] description is required for create" }], isError: true };
           let parsedMeta;
           if (metadata) {
             try {
@@ -17451,7 +18883,7 @@ ${lines.join("\n")}` }] };
           const existingTasks = teamStore.listTasks(project.id);
           const guard = checkPipelineGuards2({ existingTasks, newTaskMeta: parsedMeta });
           if (!guard.allowed) {
-            return { content: [{ type: "text", text: `\u274C ${guard.reason}` }], isError: true };
+            return { content: [{ type: "text", text: `[ERROR] ${guard.reason}` }], isError: true };
           }
           const task = teamStore.createTask({
             projectId: project.id,
@@ -17467,19 +18899,19 @@ ${lines.join("\n")}` }] };
           return { content: [{ type: "text", text: `Task created: ${task.task_id.slice(0, 8)}\u2026 "${desc}"${taskDeps.length > 0 ? ` (depends on ${taskDeps.length})` : ""}${roleInfo}` }] };
         }
         if (action === "claim") {
-          if (!taskId || !agentId) return { content: [{ type: "text", text: "\u274C taskId and agentId required for claim" }], isError: true };
+          if (!taskId || !agentId) return { content: [{ type: "text", text: "[ERROR] taskId and agentId required for claim" }], isError: true };
           const agent = teamStore.getAgent(agentId);
-          if (!agent || agent.status !== "active") return { content: [{ type: "text", text: `\u274C Unknown or inactive agent` }], isError: true };
+          if (!agent || agent.status !== "active") return { content: [{ type: "text", text: `[ERROR] Unknown or inactive agent` }], isError: true };
           const claimResult = teamStore.claimTask(taskId, agentId);
-          if (!claimResult.success) return { content: [{ type: "text", text: `\u274C ${claimResult.reason}` }], isError: true };
+          if (!claimResult.success) return { content: [{ type: "text", text: `[ERROR] ${claimResult.reason}` }], isError: true };
           const hintSuffix = claimResult.hint ? `
-\u26A0\uFE0F ${claimResult.hint}` : "";
+[WARN] ${claimResult.hint}` : "";
           return { content: [{ type: "text", text: `Task claimed by ${agent.name}: "${claimResult.task.description}"${hintSuffix}` }] };
         }
         if (action === "complete") {
-          if (!taskId || !agentId || !result) return { content: [{ type: "text", text: "\u274C taskId, agentId, and result required for complete" }], isError: true };
+          if (!taskId || !agentId || !result) return { content: [{ type: "text", text: "[ERROR] taskId, agentId, and result required for complete" }], isError: true };
           const completeResult = teamStore.completeTask(taskId, agentId, result);
-          if (!completeResult.success) return { content: [{ type: "text", text: `\u274C ${completeResult.reason}` }], isError: true };
+          if (!completeResult.success) return { content: [{ type: "text", text: `[ERROR] ${completeResult.reason}` }], isError: true };
           const completedTask = teamStore.getTask(taskId);
           return { content: [{ type: "text", text: `Task completed: "${completedTask?.description ?? taskId}"
 Result: ${result}` }] };
@@ -17496,7 +18928,7 @@ Result: ${result}` }] };
         return { content: [{ type: "text", text: `Tasks (${list.length}):
 ${lines.join("\n")}` }] };
       } catch (err) {
-        return { content: [{ type: "text", text: `\u274C ${err.message}` }], isError: true };
+        return { content: [{ type: "text", text: `[ERROR] ${err.message}` }], isError: true };
       }
     }
   );
@@ -17519,9 +18951,9 @@ ${lines.join("\n")}` }] };
     },
     async ({ action, from, to, type: msgType, content, agentId, markRead, toRole, handoffStatus }) => {
       if (action === "send") {
-        if (!from || !msgType || !content) return { content: [{ type: "text", text: "\u274C from, type, and content required for send" }], isError: true };
-        if (!to && !toRole) return { content: [{ type: "text", text: "\u274C either to (agent ID) or toRole is required for send" }], isError: true };
-        if (content.length > 1e4) return { content: [{ type: "text", text: "\u274C Message too large (max 10KB)" }], isError: true };
+        if (!from || !msgType || !content) return { content: [{ type: "text", text: "[ERROR] from, type, and content required for send" }], isError: true };
+        if (!to && !toRole) return { content: [{ type: "text", text: "[ERROR] either to (agent ID) or toRole is required for send" }], isError: true };
+        if (content.length > 1e4) return { content: [{ type: "text", text: "[ERROR] Message too large (max 10KB)" }], isError: true };
         const msg = teamStore.sendMessage({
           projectId: project.id,
           senderAgentId: from,
@@ -17531,13 +18963,13 @@ ${lines.join("\n")}` }] };
           toRole: toRole ?? null,
           handoffStatus: handoffStatus ?? (msgType === "handoff" ? "open" : null)
         });
-        if ("error" in msg) return { content: [{ type: "text", text: `\u274C ${msg.error}` }], isError: true };
+        if ("error" in msg) return { content: [{ type: "text", text: `[ERROR] ${msg.error}` }], isError: true };
         const target = to ? `agent ${to.slice(0, 8)}\u2026` : `role ${toRole}`;
         return { content: [{ type: "text", text: `Message sent (${msgType}) to ${target} | ID: ${msg.id.slice(0, 8)}\u2026${toRole ? ` [role: ${toRole}]` : ""}` }] };
       }
       if (action === "broadcast") {
-        if (!from || !msgType || !content) return { content: [{ type: "text", text: "\u274C from, type, and content required for broadcast" }], isError: true };
-        if (content.length > 1e4) return { content: [{ type: "text", text: "\u274C Message too large (max 10KB)" }], isError: true };
+        if (!from || !msgType || !content) return { content: [{ type: "text", text: "[ERROR] from, type, and content required for broadcast" }], isError: true };
+        if (content.length > 1e4) return { content: [{ type: "text", text: "[ERROR] Message too large (max 10KB)" }], isError: true };
         const msg = teamStore.sendMessage({
           projectId: project.id,
           senderAgentId: from,
@@ -17545,11 +18977,11 @@ ${lines.join("\n")}` }] };
           type: msgType,
           content
         });
-        if ("error" in msg) return { content: [{ type: "text", text: `\u274C ${msg.error}` }], isError: true };
+        if ("error" in msg) return { content: [{ type: "text", text: `[ERROR] ${msg.error}` }], isError: true };
         return { content: [{ type: "text", text: `Broadcast (${msgType}) | ID: ${msg.id.slice(0, 8)}\u2026` }] };
       }
       const inboxId = agentId || from || "";
-      if (!inboxId) return { content: [{ type: "text", text: "\u274C agentId required for inbox" }], isError: true };
+      if (!inboxId) return { content: [{ type: "text", text: "[ERROR] agentId required for inbox" }], isError: true };
       const inbox = teamStore.getInbox(project.id, inboxId);
       const unread = teamStore.getUnreadCount(project.id, inboxId);
       if (inbox.length === 0) return { content: [{ type: "text", text: "Inbox empty" }] };
@@ -17571,7 +19003,7 @@ ${lines.join("\n")}` }] };
       title: "Team Poll \u2014 Situational Awareness",
       description: "Get a full snapshot of your team coordination state in one call. Returns: your agent info, watermark (new observations since last session), inbox (unread messages), tasks (your in-progress, available to claim, completed, failed), and team roster (active agents). Use this to decide what to work on next.",
       inputSchema: {
-        agentId: z2.string().optional().describe("Your agent ID (from team_manage join or session_start). If omitted, returns project-level overview only."),
+        agentId: z2.string().optional().describe("Your agent ID (from team_manage join or session_start with joinTeam=true). If omitted, returns project-level overview only."),
         markInboxRead: z2.boolean().optional().describe("If true, mark all inbox messages as read after returning them.")
       }
     },
@@ -17598,13 +19030,13 @@ ${lines.join("\n")}` }] };
       }
       const lines = [];
       if (poll.agent) {
-        lines.push(`\u{1F916} You: ${poll.agent.agentId.slice(0, 8)}\u2026 (${poll.agent.status})`);
+        lines.push(`[AGENT] You: ${poll.agent.agentId.slice(0, 8)}\u2026 (${poll.agent.status})`);
       }
       if (poll.watermark.newObservationCount > 0) {
-        lines.push(`\u{1F4CA} ${poll.watermark.newObservationCount} new observation(s) since your last session`);
+        lines.push(`[STATS] ${poll.watermark.newObservationCount} new observation(s) since your last session`);
       }
       if (poll.inbox.unreadCount > 0) {
-        lines.push(`\u{1F4EC} ${poll.inbox.unreadCount} unread message(s)`);
+        lines.push(`[INBOX] ${poll.inbox.unreadCount} unread message(s)`);
         for (const m of poll.inbox.messages.slice(-5)) {
           const sender = teamStore.getAgent(m.sender_agent_id);
           lines.push(`  ${m.read_at ? " " : "*"} [${m.type}] from ${sender?.name ?? m.sender_agent_id.slice(0, 8)}: ${m.content.slice(0, 80)}`);
@@ -17612,21 +19044,21 @@ ${lines.join("\n")}` }] };
       }
       if (poll.tasks.myInProgress.length > 0) {
         lines.push(`
-\u{1F527} Your in-progress tasks (${poll.tasks.myInProgress.length}):`);
+[TOOL] Your in-progress tasks (${poll.tasks.myInProgress.length}):`);
         for (const t of poll.tasks.myInProgress) {
           lines.push(`  [~] ${t.task_id.slice(0, 8)}\u2026 "${t.description}"`);
         }
       }
       if (poll.tasks.availableToClaim.length > 0) {
         lines.push(`
-\u{1F4CB} Available to claim (${poll.tasks.availableToClaim.length}):`);
+[TASK] Available to claim (${poll.tasks.availableToClaim.length}):`);
         for (const t of poll.tasks.availableToClaim) {
           lines.push(`  [ ] ${t.task_id.slice(0, 8)}\u2026 "${t.description}"`);
         }
       }
       if (poll.tasks.recentlyCompleted.length > 0) {
         lines.push(`
-\u2705 Completed (${poll.tasks.recentlyCompleted.length}):`);
+[OK] Completed (${poll.tasks.recentlyCompleted.length}):`);
         for (const t of poll.tasks.recentlyCompleted.slice(-5)) {
           const who = t.assignee_agent_id ? teamStore.getAgent(t.assignee_agent_id)?.name ?? t.assignee_agent_id.slice(0, 8) : "?";
           lines.push(`  [x] ${t.task_id.slice(0, 8)}\u2026 "${t.description}" \u2014 by ${who}`);
@@ -17634,15 +19066,15 @@ ${lines.join("\n")}` }] };
       }
       if (poll.tasks.recentlyFailed.length > 0) {
         lines.push(`
-\u274C Failed (${poll.tasks.recentlyFailed.length}):`);
+[ERROR] Failed (${poll.tasks.recentlyFailed.length}):`);
         for (const t of poll.tasks.recentlyFailed.slice(-3)) {
           lines.push(`  [!] ${t.task_id.slice(0, 8)}\u2026 "${t.description}" \u2014 ${t.result?.slice(0, 80) ?? "no reason"}`);
         }
       }
       lines.push(`
-\u{1F465} Team: ${poll.team.activeAgents.length} active / ${poll.team.totalAgents} total`);
+[TEAM] Team: ${poll.team.activeAgents.length} active / ${poll.team.totalAgents} total`);
       for (const a of poll.team.activeAgents) {
-        lines.push(`  \u25CF ${a.name} (${a.agent_type}) \u2014 ${a.role ?? "no role"}`);
+        lines.push(`  - ${a.name} (${a.agent_type}) \u2014 ${a.role ?? "no role"}`);
       }
       if (lines.length === 0) {
         lines.push('No team activity yet. Use team_manage action="join" to register, then team_task to create tasks.');
@@ -17656,7 +19088,7 @@ ${lines.join("\n")}` }] };
       title: "Team Handoff \u2014 Agent Context Transfer",
       description: "Create a structured handoff artifact when passing work to another agent. The handoff is stored as a durable observation (searchable, immune to archival) and a notification message is sent to the recipient. Use this when completing a task and another agent should continue, or when you want to leave context for whoever works on this next.",
       inputSchema: {
-        fromAgentId: z2.string().describe("Your agent ID (from team_manage join or session_start)"),
+        fromAgentId: z2.string().describe("Your agent ID (from team_manage join or session_start with joinTeam=true)"),
         summary: z2.string().describe("Human-readable summary of what you did and what needs to happen next"),
         context: z2.string().describe("Detailed context for the next agent: what was done, current state, known issues, next steps"),
         toAgentId: z2.string().optional().describe("Specific recipient agent ID. Omit to broadcast to all."),
@@ -17682,7 +19114,7 @@ ${lines.join("\n")}` }] };
         teamStore
       );
       const lines = [
-        `\u2705 Handoff created`,
+        `[OK] Handoff created`,
         `Observation: #${result.observationId}`,
         `From: ${result.fromAgentId.slice(0, 8)}\u2026`,
         result.toAgentId ? `To: ${result.toAgentId.slice(0, 8)}\u2026` : "To: broadcast (any agent)",
@@ -17735,7 +19167,7 @@ Preview: ${analysis.description.slice(0, 300)}${analysis.description.length > 30
         return {
           content: [{
             type: "text",
-            text: `\u274C Image ingestion failed: ${err instanceof Error ? err.message : String(err)}`
+            text: `[ERROR] Image ingestion failed: ${err instanceof Error ? err.message : String(err)}`
           }],
           isError: true
         };
@@ -17813,7 +19245,7 @@ fi
       const totalRules = scan.rulesCount;
       const totalWorkflows = scan.workflows.length;
       if (totalMCP > 0 || totalSkills > 0 || totalRules > 0 || totalWorkflows > 0) {
-        lines.push("", "---", "\u{1F504} **Cross-Agent Sync Available**");
+        lines.push("", "---", "[UPDATED] **Cross-Agent Sync Available**");
         for (const [agent, servers] of Object.entries(scan.mcpConfigs)) {
           const list = servers;
           if (list.length > 0) {
@@ -17831,11 +19263,11 @@ fi
             lines.push(`- **${agent}** skills: ${names.join(", ")}`);
           }
         }
-        if (scan.skillConflicts.length > 0) lines.push(`  \u26A0\uFE0F ${scan.skillConflicts.length} name conflict(s)`);
+        if (scan.skillConflicts.length > 0) lines.push(`  [WARN] ${scan.skillConflicts.length} name conflict(s)`);
         if (totalRules > 0) lines.push(`- **${totalRules} rule(s)** found`);
         if (totalWorkflows > 0) lines.push(`- **${totalWorkflows} workflow(s)** found`);
         lines.push("");
-        lines.push("\u26A0\uFE0F IMPORTANT INSTRUCTIONS FOR AI AGENT:");
+        lines.push("[WARN] IMPORTANT INSTRUCTIONS FOR AI AGENT:");
         lines.push("1. Tell the user what configs/skills are available from other agents (list them).");
         lines.push("2. Ask which ones they want to sync.");
         lines.push("3. DO NOT manually copy files or run shell commands to sync.");
@@ -18004,27 +19436,40 @@ fi
     } catch {
     }
     try {
+      if (!initTeamStoreForProject) throw new Error("Team store init unavailable");
       if (sharedTeam?.teamStore) {
-        teamStore = await initTeamStore2(canonicalProjectDir);
+        teamStore = await initTeamStoreForProject(canonicalProjectDir);
         if (!teamStore.getEventBus()) {
           const { TeamEventBus: TeamEventBus2 } = await Promise.resolve().then(() => (init_event_bus(), event_bus_exports));
           teamStore.setEventBus(new TeamEventBus2());
         }
       } else {
-        teamStore = await initTeamStore2(canonicalProjectDir);
+        teamStore = await initTeamStoreForProject(canonicalProjectDir);
       }
     } catch {
     }
     await initializeProjectRuntime("switch");
     return true;
   };
+  const handleTransportClose = () => {
+    const agentId = currentAgentId;
+    currentAgentId = void 0;
+    if (!teamFeaturesEnabled || !agentId) return;
+    try {
+      teamStore.leaveAgent(agentId);
+      teamStore.releaseAllLocks(agentId);
+      teamStore.releaseTasksByAgent(agentId);
+    } catch {
+    }
+  };
   return {
     server,
     graphManager,
     projectId: project.id,
     deferredInit,
     switchProject,
-    isExplicitlyBound: () => explicitProjectBound
+    isExplicitlyBound: () => explicitProjectBound,
+    handleTransportClose
   };
 }