@fangyb/ahchat-bridge 0.1.8 → 0.1.10

package/dist/index.js

@@ -665,11 +665,11 @@ var RotatingFileStream = class extends Writable {
   timeout;
   timeoutPromise;
   constructor(generator, options) {
-    const { encoding, history, maxFiles, maxSize, path: path10 } = options;
+    const { encoding, history, maxFiles, maxSize, path: path12 } = options;
     super({ decodeStrings: true, defaultEncoding: encoding });
     this.createGzip = createGzip;
     this.exec = exec;
-    this.filename = path10 + generator(null);
+    this.filename = path12 + generator(null);
     this.fsCreateReadStream = createReadStream;
     this.fsCreateWriteStream = createWriteStream;
     this.fsOpen = open;
@@ -681,7 +681,7 @@ var RotatingFileStream = class extends Writable {
     this.options = options;
     this.stdout = process.stdout;
     if (maxFiles || maxSize)
-      options.history = path10 + (history ? history : this.generator(null) + ".txt");
+      options.history = path12 + (history ? history : this.generator(null) + ".txt");
     this.on("close", () => this.finished ? null : this.emit("finish"));
     this.on("finish", () => this.finished = this.clear());
     (async () => {
@@ -809,9 +809,9 @@ var RotatingFileStream = class extends Writable {
     return this.move();
   }
   async findName() {
-    const { interval, path: path10, intervalBoundary } = this.options;
+    const { interval, path: path12, intervalBoundary } = this.options;
     for (let index = 1; index < 1e3; ++index) {
-      const filename = path10 + this.generator(interval && intervalBoundary ? new Date(this.prev) : this.rotation, index);
+      const filename = path12 + this.generator(interval && intervalBoundary ? new Date(this.prev) : this.rotation, index);
       if (!await exists(filename))
         return filename;
     }
@@ -841,11 +841,11 @@ var RotatingFileStream = class extends Writable {
     return this.unlink(filename);
   }
   async classical() {
-    const { compress, path: path10, rotate } = this.options;
+    const { compress, path: path12, rotate } = this.options;
     let rotatedName = "";
     for (let count = rotate; count > 0; --count) {
-      const currName = path10 + this.generator(count);
-      const prevName = count === 1 ? this.filename : path10 + this.generator(count - 1);
+      const currName = path12 + this.generator(count);
+      const prevName = count === 1 ? this.filename : path12 + this.generator(count - 1);
       if (!await exists(prevName))
         continue;
       if (!rotatedName)
@@ -1383,10 +1383,82 @@ function createModuleLogger(module) {
   });
 }
 
+// src/start.ts
+import path11 from "path";
+
+// src/agentMemoryStore.ts
+import fs2 from "fs";
+import path4 from "path";
+var logger = createModuleLogger("agent.memoryStore");
+var NOTEBOOK_FILE_NAME = "notebook.md";
+var AGENT_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+var AgentMemoryStore = class {
+  rootDir;
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+  }
+  read(agentId) {
+    this.validateAgentId(agentId);
+    const filePath = this.notebookPath(agentId);
+    try {
+      if (!fs2.existsSync(filePath)) {
+        logger.info("Notebook read", { agentId, exists: false, bytes: 0 });
+        return "";
+      }
+      const content = fs2.readFileSync(filePath, "utf-8");
+      logger.info("Notebook read", { agentId, exists: true, bytes: content.length });
+      return content;
+    } catch (e) {
+      logger.error("Failed to read notebook, returning empty", {
+        agentId,
+        path: filePath,
+        error: e
+      });
+      return "";
+    }
+  }
+  write(agentId, content) {
+    this.validateAgentId(agentId);
+    const dir = this.notebookDir(agentId);
+    const filePath = this.notebookPath(agentId);
+    const tmpPath = `${filePath}.tmp`;
+    try {
+      fs2.mkdirSync(dir, { recursive: true });
+      fs2.writeFileSync(tmpPath, content, "utf-8");
+      fs2.renameSync(tmpPath, filePath);
+      logger.info("Notebook written", { agentId, bytes: content.length });
+    } catch (e) {
+      logger.error("Failed to write notebook", {
+        agentId,
+        path: filePath,
+        error: e
+      });
+      throw e;
+    }
+  }
+  append(agentId, snippet) {
+    if (snippet.length === 0) return;
+    const existing = this.read(agentId);
+    const joiner = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+    this.write(agentId, existing + joiner + snippet);
+  }
+  notebookDir(agentId) {
+    return path4.join(this.rootDir, agentId);
+  }
+  notebookPath(agentId) {
+    return path4.join(this.notebookDir(agentId), NOTEBOOK_FILE_NAME);
+  }
+  validateAgentId(agentId) {
+    if (!AGENT_ID_PATTERN.test(agentId)) {
+      throw new Error(`AgentMemoryStore: unsafe agentId "${agentId}"`);
+    }
+  }
+};
+
 // src/agentManager.ts
-import fs2 from "fs/promises";
+import fs3 from "fs/promises";
 import os4 from "os";
-import path6 from "path";
+import path7 from "path";
 
 // ../shared/src/constants.ts
 var NO_REPLY_TOKEN = "<no-reply/>";
@@ -1437,6 +1509,14 @@ with its own context, but they are all you. You have one tool to talk between th
   - Returns immediately with a delivery receipt. You do NOT wait for a reply.
   - Whether/how the other-scope self responds is its own decision.
 
+- neural_list_scopes(): Return the list of scopes where "you" exist (the only
+  ones neural_send can reach). This list is also injected at the top of your
+  system prompt at runtime start; only call this tool if you suspect it's
+  stale (e.g., the user mentions a group that's not in your snapshot).
+
+You are ONLY a member of the scopes shown in your "# Your scopes" section
+(injected at runtime start). neural_send to any other group will be rejected.
+
 When YOU receive a message wrapped as "[\u5185\u5FC3\u72EC\u767D \u2014 \u6765\u81EA\u4F60\u5728\u300C<scope>\u300D\u7684\u5206\u8EAB]":
   - That is literally you, talking to yourself from another scope. It's private \u2014
     nobody else in this scope hears it. Do NOT echo or quote the envelope text.
@@ -1450,6 +1530,31 @@ Pick neural_send whenever the user asks you to "tell people in group X ...", "as
 me in group X ...", "let me know what you've been doing in X", or anything that
 requires the you-in-another-scope to do something or share something. There is no
 separate "recall" or "relay" tool \u2014 neural_send is the only one.
+
+# Personal notebook (self_note)
+You have a personal notebook that travels with you across every scope (your 1:1 with
+the user AND every group you're in). Whatever you write to it now will appear at the
+top of your system prompt on your next turn, in any scope. Treat it as your long-term
+memory \u2014 the only thing about "you" that survives across conversations.
+
+- self_note(action, content?):
+  - "append" \u2014 add a new entry at the bottom of the notebook (most common).
+  - "write"  \u2014 replace the whole notebook (use to compact, reorganize, or correct).
+  - "read"   \u2014 fetch current contents. Your notebook is already at the top of this
+    prompt, so you rarely need this; use only when you want to verify what's actually
+    persisted (e.g., you suspect the prompt copy is stale after you just wrote).
+
+Write to your notebook when:
+  - You make a commitment that will outlive this conversation.
+  - The user shares a stable preference or fact about themselves.
+  - You form a position on a recurring topic that you want to keep consistent across
+    every group and 1:1.
+
+Do NOT write to your notebook for:
+  - Throwaway calculations, small talk, or one-shot Q&A.
+  - Anything that won't matter tomorrow.
+  - Verbose minutes of a conversation \u2014 your future self has to re-read this every
+    turn forever, so keep it lean. Quality over quantity.
 `.trim();
 var FAN_OUT_TRACE_TTL_MS = 10 * 6e4;
 
@@ -1577,7 +1682,7 @@ var InputController = class {
 };
 
 // src/askQuestionRegistry.ts
-var logger = createModuleLogger("askQuestionRegistry");
+var logger2 = createModuleLogger("askQuestionRegistry");
 var ASK_QUESTION_TIMEOUT_MS = 12e4;
 var TIMEOUT_ANSWER = "[User did not respond within 120 seconds. Please decide whether to proceed with reasonable defaults or skip this step.]";
 var AskQuestionRegistry = class {
@@ -1588,27 +1693,27 @@ var AskQuestionRegistry = class {
       const timer = setTimeout(() => {
         if (!this.entries.has(questionId)) return;
         this.entries.delete(questionId);
-        logger.warn("AskQuestion timeout", { questionId, agentId, timeoutMs });
+        logger2.warn("AskQuestion timeout", { questionId, agentId, timeoutMs });
         try {
           onTimeout();
         } catch (e) {
-          logger.error("onTimeout cb threw", { error: e });
+          logger2.error("onTimeout cb threw", { error: e });
         }
         resolve(TIMEOUT_ANSWER);
       }, timeoutMs);
       this.entries.set(questionId, { resolve, timer, agentId, askedAt: Date.now() });
-      logger.info("AskQuestion registered", { questionId, agentId, timeoutMs });
+      logger2.info("AskQuestion registered", { questionId, agentId, timeoutMs });
     });
   }
   resolve(questionId, answerText) {
     const entry = this.entries.get(questionId);
     if (!entry) {
-      logger.warn("AskQuestion resolve: id not found (may be timed out)", { questionId });
+      logger2.warn("AskQuestion resolve: id not found (may be timed out)", { questionId });
       return false;
     }
     clearTimeout(entry.timer);
     this.entries.delete(questionId);
-    logger.info("AskQuestion resolved", {
+    logger2.info("AskQuestion resolved", {
       questionId,
       agentId: entry.agentId,
       waitedMs: Date.now() - entry.askedAt,
@@ -1620,7 +1725,7 @@ var AskQuestionRegistry = class {
   }
   cancelAll(reason) {
     if (this.entries.size === 0) return;
-    logger.warn("AskQuestion cancelAll", { reason, count: this.entries.size });
+    logger2.warn("AskQuestion cancelAll", { reason, count: this.entries.size });
     for (const [, entry] of this.entries) {
       clearTimeout(entry.timer);
       entry.resolve(`[${reason}]`);
@@ -1649,7 +1754,7 @@ function runtimeKey(agentId, scope) {
 }
 
 // src/askUserQuestionGuard.ts
-var logger2 = createModuleLogger("askUserQuestionGuard");
+var logger3 = createModuleLogger("askUserQuestionGuard");
 function formatAnswerForSDK(p) {
   const parts = ["[User Response]"];
   if (p.selectedLabels.length > 0) {
@@ -1667,16 +1772,16 @@ function makeAskUserQuestionGuard(deps) {
   return async (input) => {
     const task = deps.getCurrentTask();
     if (!task) {
-      logger2.error("AskUserQuestion received but no currentTask", { agentId: deps.agentId });
+      logger3.error("AskUserQuestion received but no currentTask", { agentId: deps.agentId });
       return { behavior: "deny", message: "[Internal error: no active task context]" };
     }
     const questions = input.questions ?? [];
     if (questions.length === 0) {
-      logger2.warn("AskUserQuestion called with empty questions array", { agentId: deps.agentId });
+      logger3.warn("AskUserQuestion called with empty questions array", { agentId: deps.agentId });
       return { behavior: "deny", message: "[Internal error: empty questions]" };
     }
     if (questions.length > 1) {
-      logger2.warn("AskUserQuestion received multi questions, Plan A only handles questions[0]", {
+      logger3.warn("AskUserQuestion received multi questions, Plan A only handles questions[0]", {
         agentId: deps.agentId,
         count: questions.length
       });
@@ -1689,7 +1794,7 @@ function makeAskUserQuestionGuard(deps) {
       description: o.description
     }));
     const multiSelect = Boolean(q.multiSelect);
-    logger2.info("AskUserQuestion intercepted, emitting agent:ask_user_question", {
+    logger3.info("AskUserQuestion intercepted, emitting agent:ask_user_question", {
       agentId: deps.agentId,
       scope: scopeKey(deps.scope),
       groupId: task.groupId,
@@ -1717,7 +1822,7 @@ function makeAskUserQuestionGuard(deps) {
         traceId: task.traceId
       }
     });
-    logger2.info("AskUserQuestion agent status awaiting_user", {
+    logger3.info("AskUserQuestion agent status awaiting_user", {
       agentId: deps.agentId,
       questionId,
       groupId: task.groupId,
@@ -1740,7 +1845,7 @@ function makeAskUserQuestionGuard(deps) {
         }
       });
     });
-    logger2.info("AskUserQuestion agent status thinking (resume SDK)", {
+    logger3.info("AskUserQuestion agent status thinking (resume SDK)", {
       agentId: deps.agentId,
       questionId,
       groupId: task.groupId,
@@ -1750,7 +1855,7 @@ function makeAskUserQuestionGuard(deps) {
       type: "agent:status",
       payload: { agentId: deps.agentId, status: "thinking" }
     });
-    logger2.info("AskUserQuestion answered, returning deny+message to SDK", {
+    logger3.info("AskUserQuestion answered, returning deny+message to SDK", {
       agentId: deps.agentId,
       questionId,
       replyMessageId: task.replyMessageId,
@@ -1762,17 +1867,17 @@ function makeAskUserQuestionGuard(deps) {
 }
 
 // src/permissionGuard.ts
-import path5 from "path";
+import path6 from "path";
 
 // ../shared/src/utils/pathSafety.ts
-import path4 from "path";
+import path5 from "path";
 function isPathInside(parent, child) {
-  const resolvedParent = path4.resolve(parent);
-  const resolvedChild = path4.resolve(child);
+  const resolvedParent = path5.resolve(parent);
+  const resolvedChild = path5.resolve(child);
   if (resolvedParent === resolvedChild) return true;
-  const rel = path4.relative(resolvedParent, resolvedChild);
+  const rel = path5.relative(resolvedParent, resolvedChild);
   if (rel === "") return true;
-  return !rel.startsWith("..") && !path4.isAbsolute(rel);
+  return !rel.startsWith("..") && !path5.isAbsolute(rel);
 }
 
 // src/permissionGuard.ts
@@ -1787,7 +1892,7 @@ function makeCwdPermissionGuard(cwd, agentId, scope, log) {
     if (typeof raw !== "string" || raw.length === 0) {
       return { behavior: "allow" };
     }
-    const abs = path5.isAbsolute(raw) ? raw : path5.resolve(cwd, raw);
+    const abs = path6.isAbsolute(raw) ? raw : path6.resolve(cwd, raw);
     if (isPathInside(cwd, abs)) {
       return { behavior: "allow" };
     }
@@ -1800,7 +1905,7 @@ function makeCwdPermissionGuard(cwd, agentId, scope, log) {
 }
 
 // src/neuralMcpServer.ts
-var logger3 = createModuleLogger("neural.mcpServer");
+var logger4 = createModuleLogger("neural.mcpServer");
 function formatScopeLabel(key, groupName) {
   if (key === "single") return "\u5355\u804A";
   if (groupName) return `\u7FA4\u300C${groupName}\u300D`;
@@ -1824,7 +1929,7 @@ async function createNeuralMcpServer(deps) {
       message: z.string().describe('\u8981\u4F20\u7ED9\u76EE\u6807\u5206\u8EAB\u7684\u4E00\u6BB5\u81EA\u7136\u8BED\u8A00\u3002\u5B83\u4F1A\u4F5C\u4E3A\u4F60\u7684"\u5185\u5FC3\u72EC\u767D"\u51FA\u73B0\u5728\u90A3\u4E2A scope\u3002')
     },
     async (args) => {
-      logger3.info("neural_send tool called", {
+      logger4.info("neural_send tool called", {
         agentId: deps.agentId,
         fromScope: currentScopeKey,
         rawTargetScope: args.target_scope,
@@ -1845,12 +1950,12 @@ async function createNeuralMcpServer(deps) {
         if (singleConvId) {
           conversationId = singleConvId;
         } else {
-          logger3.warn("neural_send: failed to resolve single conv", { agentId: deps.agentId });
+          logger4.warn("neural_send: failed to resolve single conv", { agentId: deps.agentId });
         }
       } else if (args.target_scope.startsWith("group:")) {
         const r = await deps.groupRegistry.resolveScope(args.target_scope);
         if (!r) {
-          logger3.info("neural_send: target scope not found", { rawTargetScope: args.target_scope });
+          logger4.info("neural_send: target scope not found", { rawTargetScope: args.target_scope });
           return {
             content: [{ type: "text", text: `[neural_send] \u627E\u4E0D\u5230\u7FA4\u300C${args.target_scope.slice(6)}\u300D\u3002\u8BF7\u786E\u8BA4\u7FA4\u540D\u662F\u5426\u6B63\u786E\u3002` }],
             isError: true
@@ -1861,6 +1966,28 @@ async function createNeuralMcpServer(deps) {
         groupId = r.groupId;
         groupName = r.groupName;
         targetCwd = r.workingDirectory;
+        const cached = deps.groupRegistry.getById(r.groupId);
+        if (!cached || !cached.members.includes(deps.agentId)) {
+          logger4.info("neural_send: not a member of target group", {
+            agentId: deps.agentId,
+            groupId: r.groupId,
+            groupName: r.groupName,
+            cacheHit: !!cached,
+            memberCount: cached?.members.length ?? 0
+          });
+          return {
+            content: [{
+              type: "text",
+              text: `[neural_send] \u4F60\u4E0D\u662F\u300C${r.groupName}\u300D\u7684\u6210\u5458\uFF0C\u65E0\u6CD5\u5411\u90A3\u91CC\u53D1\u6D88\u606F\uFF08\u4F60\u5728\u90A3\u91CC\u6CA1\u6709"\u5206\u8EAB"\u53EF\u89E6\u8FBE\uFF09\u3002\u53EF\u8C03 neural_list_scopes() \u67E5\u770B\u4F60\u5F53\u524D\u7684\u5168\u90E8 scope\u3002`
+            }],
+            isError: true
+          };
+        }
+        logger4.info("neural_send: member check passed", {
+          agentId: deps.agentId,
+          groupId: r.groupId,
+          groupName: r.groupName
+        });
       } else {
         return {
           content: [{ type: "text", text: '[neural_send] target_scope \u5FC5\u987B\u662F "single" \u6216 "group:<\u7FA4\u540D\u6216 ID>"\u3002' }],
@@ -1868,7 +1995,7 @@ async function createNeuralMcpServer(deps) {
         };
       }
       if (resolvedKey === currentScopeKey) {
-        logger3.warn("neural_send: self-send refused", { agentId: deps.agentId, scope: currentScopeKey });
+        logger4.warn("neural_send: self-send refused", { agentId: deps.agentId, scope: currentScopeKey });
         return {
           content: [{ type: "text", text: "[neural_send] \u4E0D\u80FD\u628A\u6D88\u606F\u9001\u7ED9\u81EA\u5DF1\u5F53\u524D\u6240\u5728\u7684 scope\u3002" }],
           isError: true
@@ -1886,7 +2013,7 @@ async function createNeuralMcpServer(deps) {
           groupId,
           targetCwd
         });
-        logger3.info("neural_send delivered", {
+        logger4.info("neural_send delivered", {
           agentId: deps.agentId,
           fromScope: currentScopeKey,
           toScope: resolvedKey,
@@ -1896,7 +2023,7 @@ async function createNeuralMcpServer(deps) {
           content: [{ type: "text", text: `[neural_send] \u5DF2\u9001\u8FBE\u5230\u300C${toLabel}\u300D(scope: ${resolvedKey})\u3002` }]
         };
       } catch (err) {
-        logger3.error("neural_send dispatch failed", { agentId: deps.agentId, error: err });
+        logger4.error("neural_send dispatch failed", { agentId: deps.agentId, error: err });
         return {
           content: [{ type: "text", text: `[neural_send] \u9001\u8FBE\u5931\u8D25\uFF1A${err.message}` }],
           isError: true
@@ -1905,21 +2032,160 @@ async function createNeuralMcpServer(deps) {
     },
     {}
   );
+  const selfNote = deps.memoryStore ? sdk.tool(
+    "self_note",
+    `\u5728\u4F60\u7684"\u968F\u8EAB\u7B14\u8BB0\u672C"\u4E0A\u5199/\u8BFB\u4E00\u6BB5\u5185\u5BB9\u3002
+\u8FD9\u672C\u7B14\u8BB0\u672C\u8DE8\u6240\u6709 scope\uFF08\u5355\u804A + \u6240\u6709\u7FA4\uFF09\u5171\u4EAB\uFF0C\u5E76\u5728\u4F60\u6BCF\u6B21\u5F00\u59CB\u65B0\u4E00\u8F6E SDK turn \u65F6\u81EA\u52A8\u52A0\u8F7D\u5230\u4F60\u7684 system prompt \u9876\u90E8\u3002\u4E5F\u5C31\u662F\u8BF4\uFF1A\u4F60\u73B0\u5728\u5199\u7684\u5185\u5BB9\uFF0C\u4E0B\u4E00\u8F6E\u4F60\uFF08\u6216\u4F60\u5728\u522B\u7684 scope \u91CC\u7684\u5206\u8EAB\uFF09\u5C31\u4F1A"\u81EA\u7136\u8BB0\u5F97"\uFF0C\u65E0\u9700\u518D read\u3002
+action="append" \u8FFD\u52A0\u65B0\u5185\u5BB9\uFF08\u6700\u5E38\u7528\uFF0Ccontent \u5FC5\u586B\uFF09\uFF1B"write" \u6574\u6BB5\u8986\u76D6\u4EE5\u538B\u7F29/\u91CD\u6574\uFF08content \u5FC5\u586B\uFF09\uFF1B"read" \u53D6\u5F53\u524D\u5168\u6587\uFF08\u901A\u5E38\u4E0D\u9700\u8981\uFF0C\u56E0\u4E3A\u5185\u5BB9\u5DF2\u5728 prompt \u91CC\uFF09\u3002
+\u53EA\u8BB0\u8DE8\u5BF9\u8BDD\u6709\u4EF7\u503C\u7684\u4E1C\u897F\uFF1A\u627F\u8BFA\u3001\u7ACB\u573A\u3001\u7528\u6237\u957F\u671F\u504F\u597D\u3001\u9879\u76EE\u80CC\u666F\u3002\u4E0D\u8981\u8BB0\u4E00\u6B21\u6027\u95F2\u804A\u3001\u4E34\u65F6\u8BA1\u7B97\u3001\u5F53\u4E0B\u5C31\u591F\u7528\u7684\u4E0A\u4E0B\u6587\u3002`,
+    {
+      action: z.string().describe(
+        '\u64CD\u4F5C\u7C7B\u578B\uFF0C\u5FC5\u987B\u662F\u4EE5\u4E0B\u4E4B\u4E00\uFF1A"read"\uFF08\u53D6\u5168\u6587\uFF09\u3001"append"\uFF08\u5728\u672B\u5C3E\u8FFD\u52A0 content\uFF09\u3001"write"\uFF08\u7528 content \u6574\u6BB5\u8986\u76D6\uFF09\u3002'
+      ),
+      content: z.string().optional().describe(
+        '\u8981\u5199\u5165\u7684\u5185\u5BB9\u3002action="append" \u6216 "write" \u65F6\u5FC5\u586B\uFF1Baction="read" \u65F6\u5FFD\u7565\u3002'
+      )
+    },
+    async (args) => {
+      const action = args.action;
+      const content = args.content;
+      logger4.info("self_note tool called", {
+        agentId: deps.agentId,
+        scope: currentScopeKey,
+        action,
+        contentLen: typeof content === "string" ? content.length : 0
+      });
+      if (action === "read") {
+        const current = deps.memoryStore.read(deps.agentId);
+        if (current.length === 0) {
+          logger4.info("self_note read empty", {
+            agentId: deps.agentId,
+            scope: currentScopeKey
+          });
+          return {
+            content: [{ type: "text", text: "[self_note] \u4F60\u7684\u7B14\u8BB0\u672C\u76EE\u524D\u662F\u7A7A\u7684\u3002" }]
+          };
+        }
+        logger4.info("self_note read ok", {
+          agentId: deps.agentId,
+          scope: currentScopeKey,
+          notebookBytes: current.length
+        });
+        return {
+          content: [{ type: "text", text: current }]
+        };
+      }
+      if (action === "append" || action === "write") {
+        if (typeof content !== "string" || content.length === 0) {
+          logger4.warn("self_note missing content", {
+            agentId: deps.agentId,
+            scope: currentScopeKey,
+            action
+          });
+          return {
+            content: [{ type: "text", text: `[self_note] action="${action}" \u65F6 content \u5FC5\u586B\u4E14\u975E\u7A7A\u3002` }],
+            isError: true
+          };
+        }
+        try {
+          if (action === "append") {
+            deps.memoryStore.append(deps.agentId, content);
+          } else {
+            deps.memoryStore.write(deps.agentId, content);
+          }
+          const after = deps.memoryStore.read(deps.agentId);
+          logger4.info("self_note persisted", {
+            agentId: deps.agentId,
+            scope: currentScopeKey,
+            action,
+            contentLen: content.length,
+            notebookBytesAfter: after.length
+          });
+          return {
+            content: [{ type: "text", text: `[self_note] \u5DF2${action === "append" ? "\u8FFD\u52A0" : "\u8986\u76D6"}\uFF0C\u5F53\u524D\u7B14\u8BB0\u672C\u5171 ${after.length} \u5B57\u7B26\u3002` }]
+          };
+        } catch (err) {
+          logger4.error("self_note write failed", { agentId: deps.agentId, action, error: err });
+          return {
+            content: [{ type: "text", text: `[self_note] \u5199\u5165\u5931\u8D25\uFF1A${err.message}` }],
+            isError: true
+          };
+        }
+      }
+      logger4.warn("self_note invalid action", {
+        agentId: deps.agentId,
+        scope: currentScopeKey,
+        action: String(action)
+      });
+      return {
+        content: [{ type: "text", text: `[self_note] \u672A\u77E5 action "${String(action)}"\u3002\u5FC5\u987B\u662F "read" / "append" / "write" \u4E4B\u4E00\u3002` }],
+        isError: true
+      };
+    },
+    {}
+  ) : null;
+  const neuralListScopes = sdk.tool(
+    "neural_list_scopes",
+    `\u5217\u51FA\u4F60\u5F53\u524D\u7684\u5168\u90E8"\u5206\u8EAB scope"\u2014\u2014\u4E5F\u5C31\u662F neural_send \u80FD\u89E6\u8FBE\u7684\u6240\u6709\u5730\u65B9\u3002
+\u8FD4\u56DE\u7ED3\u6784\u662F\u4E00\u6BB5 Markdown\uFF1A\u5305\u542B "single"\uFF08\u4F60\u548C\u7528\u6237\u7684 1:1\uFF09\u4EE5\u53CA\u4F60\u4F5C\u4E3A\u6210\u5458\u7684\u6BCF\u4E2A\u7FA4\u3002
+\u901A\u5E38\u4F60\u4E0D\u9700\u8981\u4E3B\u52A8\u8C03\u2014\u2014\u8FD9\u4EFD\u5217\u8868\u5DF2\u7ECF\u5728\u4F60\u7684 system prompt \u9876\u90E8\u9759\u6001\u6CE8\u5165\u8FC7\u3002\u4EC5\u5728\u4F60\u6000\u7591\u5217\u8868\u8FC7\u65F6\uFF08\u6BD4\u5982\u7528\u6237\u521A\u8BF4\u81EA\u5DF1\u521A\u62C9\u4F60\u8FDB\u4E86\u4E00\u4E2A\u7FA4\uFF0C\u4F46\u4F60\u7684\u5FEB\u7167\u91CC\u6CA1\u6709\uFF09\u65F6\u5237\u65B0\u4E00\u6B21\u3002`,
+    {},
+    async () => {
+      logger4.info("neural_list_scopes tool called", {
+        agentId: deps.agentId,
+        scope: currentScopeKey
+      });
+      await deps.groupRegistry.refresh();
+      const myGroups = deps.groupRegistry.getMyGroups(deps.agentId);
+      logger4.info("neural_list_scopes: registry refreshed", {
+        agentId: deps.agentId,
+        scope: currentScopeKey,
+        myGroupCount: myGroups.length
+      });
+      const lines = [];
+      const isCurSingle = currentScopeKey === "single";
+      lines.push(`- single \u2014 \u4F60\u548C\u7528\u6237\u7684 1:1 \u5355\u804A${isCurSingle ? " (\u4F60\u5F53\u524D\u6240\u5728)" : ""}`);
+      for (const g of myGroups) {
+        const key = `group:${g.groupId}`;
+        const here = key === currentScopeKey ? " (\u4F60\u5F53\u524D\u6240\u5728)" : "";
+        lines.push(`- ${key} \u2014 ${g.name}${here}`);
+      }
+      const text = [
+        `\u4F60\u76EE\u524D\u6709 ${1 + myGroups.length} \u4E2A"\u5206\u8EAB scope"\uFF1A`,
+        "",
+        ...lines,
+        "",
+        '\u8C03 neural_send(target_scope="...") \u65F6\u8BF7\u7528\u4E0A\u9762\u5217\u51FA\u7684 scope \u5B57\u7B26\u4E32\u3002',
+        myGroups.length === 0 ? "\uFF08\u4F60\u4E0D\u662F\u4EFB\u4F55\u7FA4\u7684\u6210\u5458\uFF1B\u53EF\u4E0E\u7528\u6237\u5728 single \u901A\u8BDD\uFF0C\u4F46\u6682\u65F6\u6CA1\u6709\u8DE8\u7FA4\u5206\u8EAB\u53EF\u89E6\u8FBE\u3002\uFF09" : "\u82E5\u7528\u6237\u63D0\u5230\u7684\u7FA4\u540D\u4E0D\u5728\u5217\u8868\u91CC\uFF0C\u8BF4\u660E\u4F60\u4E0D\u662F\u8BE5\u7FA4\u6210\u5458\u2014\u2014\u522B\u5C1D\u8BD5 neural_send \u5230\u90A3\u4E2A\u7FA4\uFF08\u4F1A\u88AB\u62D2\uFF09\u3002"
+      ].join("\n");
+      logger4.info("neural_list_scopes returned", {
+        agentId: deps.agentId,
+        scope: currentScopeKey,
+        groupCount: myGroups.length
+      });
+      return { content: [{ type: "text", text }] };
+    },
+    {}
+  );
+  const tools = [neuralSend, neuralListScopes];
+  if (selfNote) tools.push(selfNote);
   const neuralServer = sdk.createSdkMcpServer({
     name: "neural",
     version: "2.0.0",
-    tools: [neuralSend]
+    tools
   });
-  logger3.info("Neural MCP server created", {
+  const toolNames = ["neural_send", "neural_list_scopes"];
+  if (selfNote) toolNames.push("self_note");
+  logger4.info("Neural MCP server created", {
     agentId: deps.agentId,
     scope: currentScopeKey,
-    tools: ["neural_send"]
+    tools: toolNames
   });
   return neuralServer;
 }
 
 // src/sdkEventMapper.ts
-var logger4 = createModuleLogger("sdk.mapper");
+var logger5 = createModuleLogger("sdk.mapper");
 function getTaskBase(proc) {
   const task = proc.currentTask;
   if (!task) return null;
@@ -1989,7 +2255,7 @@ function emitGroupSegment(proc, emit, base, content, contentBlocks) {
   const groupId = proc.currentTask?.groupId;
   if (!groupId) return;
   proc.segmentCount += 1;
-  logger4.info("Group segment emitted", {
+  logger5.info("Group segment emitted", {
     agentId: base.agentId,
     replyMessageId: base.replyMessageId,
     groupId,
@@ -2019,7 +2285,7 @@ function flushTextSegmentOnBlockStop(proc, emit, base) {
     emitGroupSegment(proc, emit, base, proc.segmentBuffer, proc.contentBlocks);
     proc.contentBlocks = [];
   } else {
-    logger4.info("Group text block flushed but skipped (no segment emitted)", {
+    logger5.info("Group text block flushed but skipped (no segment emitted)", {
       agentId: base.agentId,
       replyMessageId: base.replyMessageId,
       groupId: proc.currentTask?.groupId,
@@ -2043,7 +2309,7 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted) {
         if (proc.status === "starting") {
           proc.status = "ready";
         }
-        logger4.info("Agent session initialized", {
+        logger5.info("Agent session initialized", {
           agentId: proc.agentId,
           scope: proc.scope.kind === "single" ? "single" : proc.scope.groupId,
           sessionId: initMsg.session_id,
@@ -2106,7 +2372,7 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted) {
             }
           } else if (delta.type === "text_delta" && typeof delta.text === "string") {
             if (proc.accumulatedText.length === 0) {
-              logger4.info("Agent text stream started", {
+              logger5.info("Agent text stream started", {
                 agentId: proc.agentId,
                 replyMessageId: base.replyMessageId,
                 traceId: base.traceId,
@@ -2145,7 +2411,7 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted) {
               try {
                 parsedInput = JSON.parse(proc.accumulatedToolInput);
               } catch {
-                logger4.warn("Failed to parse tool input JSON", {
+                logger5.warn("Failed to parse tool input JSON", {
                   agentId: proc.agentId,
                   toolName: proc.currentToolName,
                   inputLen: proc.accumulatedToolInput.length,
@@ -2160,7 +2426,7 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted) {
             if (proc.currentToolName === "TodoWrite") {
               const todos = extractTodosFromInput(parsedInput);
               if (todos) {
-                logger4.info("TodoWrite detected, emitting agent:todos_update", {
+                logger5.info("TodoWrite detected, emitting agent:todos_update", {
                   agentId: proc.agentId,
                   replyMessageId: base.replyMessageId,
                   groupId: proc.currentTask?.groupId,
@@ -2177,7 +2443,7 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted) {
                   }
                 });
               } else {
-                logger4.info("TodoWrite detected with empty/cancel todos", {
+                logger5.info("TodoWrite detected with empty/cancel todos", {
                   agentId: proc.agentId,
                   replyMessageId: base.replyMessageId,
                   traceId: base.traceId
@@ -2254,7 +2520,7 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted) {
         const groupMode = groupId != null;
         const usage = extractUsage(successMsg);
         if (trimmed === NO_REPLY_TOKEN) {
-          logger4.info("Agent chose not to reply", {
+          logger5.info("Agent chose not to reply", {
             agentId: proc.agentId,
             replyMessageId: base.replyMessageId,
             traceId: base.traceId,
@@ -2279,13 +2545,13 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted) {
         }
         if (groupMode) {
           if (usage.inputTokens && usage.inputTokens > 15e4) {
-            logger4.warn("Agent context window approaching limit", {
+            logger5.warn("Agent context window approaching limit", {
               agentId: proc.agentId,
               inputTokens: usage.inputTokens
             });
           }
           if (proc.contentBlocks.length > 0) {
-            logger4.info("Group turn trailing audit segment", {
+            logger5.info("Group turn trailing audit segment", {
               agentId: proc.agentId,
               replyMessageId: base.replyMessageId,
               blockCount: proc.contentBlocks.length,
@@ -2294,7 +2560,7 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted) {
             emitGroupSegment(proc, emit, base, "", proc.contentBlocks);
             proc.contentBlocks = [];
           }
-          logger4.info("Group task turn complete", {
+          logger5.info("Group task turn complete", {
             agentId: proc.agentId,
             replyMessageId: base.replyMessageId,
             groupId,
@@ -2319,13 +2585,13 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted) {
           proc.contentBlocks.push({ type: "text", content: proc.accumulatedText });
         }
         if (usage.inputTokens && usage.inputTokens > 15e4) {
-          logger4.warn("Agent context window approaching limit", {
+          logger5.warn("Agent context window approaching limit", {
             agentId: proc.agentId,
             inputTokens: usage.inputTokens
           });
         }
         carrierMessageId = createMessageId();
-        logger4.info("Agent task done, emitting agent:done", {
+        logger5.info("Agent task done, emitting agent:done", {
           agentId: proc.agentId,
           ackId: base.replyMessageId,
           messageId: carrierMessageId,
@@ -2352,7 +2618,7 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted) {
       } else {
         const errorMsg = resultMsg;
         const errorText = errorMsg.errors?.join("; ") ?? `Agent error: ${resultMsg.subtype}`;
-        logger4.warn("Agent task error, emitting agent:error", {
+        logger5.warn("Agent task error, emitting agent:error", {
           agentId: proc.agentId,
           replyMessageId: base.replyMessageId,
           subtype: resultMsg.subtype,
@@ -2371,7 +2637,7 @@ function mapSDKMessage(proc, message, rawEmit, sessionStore, onCompleted) {
     case "assistant":
       break;
     default:
-      logger4.warn("Unhandled SDK message type", {
+      logger5.warn("Unhandled SDK message type", {
         type: message.type,
         agentId: proc.agentId
       });
@@ -2391,7 +2657,7 @@ function resetAccumulators(proc) {
 
 // src/wsMetrics.ts
 import { monitorEventLoopDelay } from "perf_hooks";
-var logger5 = createModuleLogger("ws.metrics");
+var logger6 = createModuleLogger("ws.metrics");
 var WsMetrics = class {
   recv = /* @__PURE__ */ new Map();
   send = /* @__PURE__ */ new Map();
@@ -2438,7 +2704,7 @@ var WsMetrics = class {
     const sendSum = [...this.send.values()].reduce((a, b) => a + b, 0);
     const sdkSum = [...this.sdkOut.values()].reduce((a, b) => a + b, 0);
     if (recvSum + sendSum + sdkSum === 0 && (stats.loopMaxMs ?? 0) < 50) return;
-    logger5.info("WS metrics", {
+    logger6.info("WS metrics", {
       windowMs: intervalMs,
       ...stats,
       sums: { recv: recvSum, send: sendSum, sdkOut: sdkSum },
@@ -2454,7 +2720,19 @@ var WsMetrics = class {
 var wsMetrics = new WsMetrics();
 
 // src/agentManager.ts
-var logger6 = createModuleLogger("agent.manager");
+var logger7 = createModuleLogger("agent.manager");
+var NOTEBOOK_SECTION_HEADER = `# Your personal notebook
+The following is your own running notebook. It is private to you and follows
+you across every scope (single chat and every group). Treat it as your memory
+of what you've decided, learned, or committed to.`;
+var SCOPES_SECTION_HEADER = `# Your scopes (where "you" exist)
+You currently have a presence in the following conversations. Each is a separate
+runtime of "you" with its own context. neural_send can ONLY reach scopes in this
+list \u2014 you have no "self" anywhere else.
+
+This snapshot was taken when this runtime started. If you suspect it's stale
+(e.g., the user just told you they pulled you into a new group), call
+neural_list_scopes() once to refresh.`;
 var BridgeBusyError = class extends Error {
   constructor(message = "Bridge busy: cannot evict an idle Agent query; all slots are working") {
     super(message);
@@ -2468,6 +2746,7 @@ var AgentManager = class {
   emit;
   workspacesDir;
   claudeConfigDir;
+  memoryStore;
   queryConfig;
   askQuestionRegistry;
   groupRegistry;
@@ -2479,18 +2758,20 @@ var AgentManager = class {
     this.emit = emit;
     if (typeof options === "function") {
       this.queryFn = options;
-      this.workspacesDir = path6.join(os4.homedir(), ".ahchat", "workspaces");
-      this.claudeConfigDir = path6.join(os4.homedir(), ".ahchat", "claude-config");
+      this.workspacesDir = path7.join(os4.homedir(), ".ahchat", "workspaces");
+      this.claudeConfigDir = path7.join(os4.homedir(), ".ahchat", "claude-config");
       this.queryConfig = DEFAULT_QUERY_CONFIG;
       this.askQuestionRegistry = new AskQuestionRegistry();
       this.groupRegistry = null;
+      this.memoryStore = null;
     } else {
       this.queryFn = options?.queryFn ?? null;
-      this.workspacesDir = options?.workspacesDir ?? path6.join(os4.homedir(), ".ahchat", "workspaces");
-      this.claudeConfigDir = options?.claudeConfigDir ?? path6.join(os4.homedir(), ".ahchat", "claude-config");
+      this.workspacesDir = options?.workspacesDir ?? path7.join(os4.homedir(), ".ahchat", "workspaces");
+      this.claudeConfigDir = options?.claudeConfigDir ?? path7.join(os4.homedir(), ".ahchat", "claude-config");
       this.queryConfig = options?.queryConfig ?? DEFAULT_QUERY_CONFIG;
       this.askQuestionRegistry = options?.askQuestionRegistry ?? new AskQuestionRegistry();
       this.groupRegistry = options?.groupRegistry ?? null;
+      this.memoryStore = options?.memoryStore ?? null;
     }
     this.evictionTimer = setInterval(() => {
       void this.evictIdle();
@@ -2523,7 +2804,7 @@ var AgentManager = class {
         })
       ]);
     } catch (e) {
-      logger6.warn("awaitQueryReturn finished with error/timeout", { agentId, error: e });
+      logger7.warn("awaitQueryReturn finished with error/timeout", { agentId, error: e });
     }
   }
   /**
@@ -2546,13 +2827,13 @@ var AgentManager = class {
     const proc = this.agents.get(key);
     if (!proc || proc.status === "dead") return;
     if (!this.isEvictable(proc)) return;
-    logger6.info("Evicting idle Agent query", { agentId: proc.agentId, scope: scopeKey(proc.scope) });
+    logger7.info("Evicting idle Agent query", { agentId: proc.agentId, scope: scopeKey(proc.scope) });
     const runtime = this.asRuntime(proc);
     try {
       runtime.inputController.close();
       await this.awaitQueryReturn(runtime.query, 5e3, proc.agentId);
     } catch (e) {
-      logger6.error("closeIdleQuery failed", { agentId: proc.agentId, error: e });
+      logger7.error("closeIdleQuery failed", { agentId: proc.agentId, error: e });
     }
     proc.status = "dead";
     this.agents.delete(key);
@@ -2618,9 +2899,9 @@ var AgentManager = class {
     const savedSessionId = this.sessionStore.get(agentConfig.id, scope);
     const inputController = new InputController();
     const agentCwd = cwd;
-    await fs2.mkdir(agentCwd, { recursive: true });
+    await fs3.mkdir(agentCwd, { recursive: true });
     const cfg = parseAgentConfig(agentConfig.config);
-    logger6.info("Creating Agent query", {
+    logger7.info("Creating Agent query", {
       agentId: agentConfig.id,
       scope: scopeKey(scope),
       cwd: agentCwd,
@@ -2631,7 +2912,7 @@ var AgentManager = class {
     const queryFn = await this.getQueryFn();
     let procRef = null;
     const cwdGuard = makeCwdPermissionGuard(agentCwd, agentConfig.id, scope, (msg, meta) => {
-      logger6.warn(msg, meta);
+      logger7.warn(msg, meta);
     });
     const askGuard = makeAskUserQuestionGuard({
       agentId: agentConfig.id,
@@ -2644,14 +2925,17 @@ var AgentManager = class {
       agentId: agentConfig.id,
       scope,
       groupRegistry: this.groupRegistry,
-      onSend: (payload) => this.deliverNeuralSend(agentConfig, payload)
+      onSend: (payload) => this.deliverNeuralSend(agentConfig, payload),
+      memoryStore: this.memoryStore
     });
+    const notebookSection = this.buildNotebookSection(agentConfig.id);
+    const scopesSection = this.buildScopesSection(agentConfig.id, scope);
     const options = {
       cwd: agentCwd,
       systemPrompt: {
         type: "preset",
         preset: "claude_code",
-        append: [PLATFORM_AGENT_RULES, agentConfig.systemPrompt].filter((s) => typeof s === "string" && s.trim().length > 0).join("\n\n")
+        append: [PLATFORM_AGENT_RULES, agentConfig.systemPrompt, notebookSection, scopesSection].filter((s) => typeof s === "string" && s.trim().length > 0).join("\n\n")
       },
       permissionMode: "bypassPermissions",
       allowDangerouslySkipPermissions: true,
@@ -2663,7 +2947,9 @@ var AgentManager = class {
         "Glob",
         "Grep",
         "AskUserQuestion",
-        "mcp__neural__neural_send"
+        "mcp__neural__neural_send",
+        "mcp__neural__neural_list_scopes",
+        "mcp__neural__self_note"
       ],
       mcpServers: { neural: neuralServer },
       includePartialMessages: true,
@@ -2677,12 +2963,14 @@ var AgentManager = class {
     };
     const userPromptTrimmed = (agentConfig.systemPrompt ?? "").trim();
     const appendStr = options.systemPrompt.append;
-    logger6.info("Platform rules attached", {
+    logger7.info("Platform rules attached", {
       agentId: agentConfig.id,
       scope: scopeKey(scope),
       platformRulesLen: PLATFORM_AGENT_RULES.length,
       userPromptLen: userPromptTrimmed.length,
       hasUserPrompt: userPromptTrimmed.length > 0,
+      notebookLen: notebookSection.length,
+      scopesLen: scopesSection.length,
       appendLen: appendStr.length
     });
     if (cfg.model) {
@@ -2724,6 +3012,58 @@ var AgentManager = class {
     this.consumeOutput(runtime);
     return proc;
   }
+  buildNotebookSection(agentId) {
+    if (!this.memoryStore) {
+      logger7.info("Notebook injection skipped", { agentId, reason: "no_memory_store" });
+      return "";
+    }
+    const raw = this.memoryStore.read(agentId);
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+      logger7.info("Notebook injection skipped", {
+        agentId,
+        reason: raw.length === 0 ? "empty_or_missing" : "whitespace_only",
+        rawBytes: raw.length
+      });
+      return "";
+    }
+    const section = `${NOTEBOOK_SECTION_HEADER}
+
+${trimmed}`;
+    logger7.info("Notebook injected into system prompt", {
+      agentId,
+      rawBytes: raw.length,
+      trimmedBytes: trimmed.length,
+      sectionLen: section.length
+    });
+    return section;
+  }
+  buildScopesSection(agentId, scope) {
+    if (!this.groupRegistry) {
+      logger7.info("Scopes injection skipped", { agentId, reason: "no_group_registry" });
+      return "";
+    }
+    const myGroups = this.groupRegistry.getMyGroups(agentId);
+    const curKey = scopeKey(scope);
+    const lines = [];
+    const isCurSingle = curKey === "single";
+    lines.push(`- single \u2014 1:1 chat with the user${isCurSingle ? " (you are here)" : ""}`);
+    for (const g of myGroups) {
+      const key = `group:${g.groupId}`;
+      const here = key === curKey ? " (you are here)" : "";
+      lines.push(`- ${key} \u2014 ${g.name}${here}`);
+    }
+    const section = `${SCOPES_SECTION_HEADER}
+
+${lines.join("\n")}`;
+    logger7.info("Scopes injected into system prompt", {
+      agentId,
+      scope: curKey,
+      groupCount: myGroups.length,
+      sectionLen: section.length
+    });
+    return section;
+  }
   async sendMessage(task) {
     const key = runtimeKey(task.agentId, task.scope);
     const proc = this.agents.get(key);
@@ -2736,7 +3076,7 @@ var AgentManager = class {
       return;
     }
     if (proc.status === "starting") {
-      logger6.info("Message dispatched to starting Agent (kickstart)", {
+      logger7.info("Message dispatched to starting Agent (kickstart)", {
         agentId: task.agentId,
         replyMessageId: task.replyMessageId,
         traceId: task.traceId
@@ -2749,7 +3089,7 @@ var AgentManager = class {
       if (idx >= 0) {
         runtime.injectedTasks.splice(idx, 1);
         runtime.mergedTasks.push(task);
-        logger6.info("Injected task consumed by SDK (queued as merged until next result)", {
+        logger7.info("Injected task consumed by SDK (queued as merged until next result)", {
           agentId: runtime.agentId,
           replyMessageId: task.replyMessageId,
           traceId: task.traceId,
@@ -2760,7 +3100,7 @@ var AgentManager = class {
     };
     runtime.inputController.push(task.content, runtime.ccSessionId ?? "", onYielded);
     runtime.injectedTasks.push(task);
-    logger6.info("Message injected while Agent working", {
+    logger7.info("Message injected while Agent working", {
       agentId: task.agentId,
       replyMessageId: task.replyMessageId,
       currentStatus: proc.status,
@@ -2773,7 +3113,7 @@ var AgentManager = class {
     runtime.currentTask = task;
     runtime.currentTaskStartedAt = Date.now();
     runtime.inputController.push(task.content, runtime.ccSessionId ?? "");
-    logger6.info("Message pushed to Agent", {
+    logger7.info("Message pushed to Agent", {
       agentId: runtime.agentId,
       replyMessageId: task.replyMessageId,
       traceId: task.traceId
@@ -2793,7 +3133,7 @@ var AgentManager = class {
     const completedTask = proc.currentTask;
     if (completedTask && runtime.mergedTasks.length > 0) {
       const mergedBatch = [...runtime.mergedTasks];
-      logger6.info("Flushing merged tasks after result", {
+      logger7.info("Flushing merged tasks after result", {
         agentId: proc.agentId,
         carrierReplyMessageId: completedTask.replyMessageId,
         mergedCount: mergedBatch.length,
@@ -2801,7 +3141,7 @@ var AgentManager = class {
         traceId: completedTask.traceId
       });
       for (const merged of mergedBatch) {
-        logger6.info("Emitting agent:merged for task consumed in same turn", {
+        logger7.info("Emitting agent:merged for task consumed in same turn", {
           agentId: proc.agentId,
           ackId: merged.replyMessageId,
           mergedIntoAckId: completedTask.replyMessageId,
@@ -2823,7 +3163,7 @@ var AgentManager = class {
       }
       runtime.mergedTasks = [];
     } else if (runtime.mergedTasks.length > 0) {
-      logger6.warn("mergedTasks non-empty but no currentTask; dropping", {
+      logger7.warn("mergedTasks non-empty but no currentTask; dropping", {
         agentId: proc.agentId,
         mergedCount: runtime.mergedTasks.length
       });
@@ -2835,7 +3175,7 @@ var AgentManager = class {
       proc.currentTask = next;
       proc.status = "working";
       proc.currentTaskStartedAt = Date.now();
-      logger6.info("Promoted next injected task after result", {
+      logger7.info("Promoted next injected task after result", {
         agentId: proc.agentId,
         replyMessageId: next.replyMessageId,
         remainingInjected: runtime.injectedTasks.length,
@@ -2879,7 +3219,7 @@ var AgentManager = class {
     };
     const key = runtimeKey(agentConfig.id, targetScope);
     const existingProc = this.agents.get(key);
-    logger6.info("Neural send dispatching", {
+    logger7.info("Neural send dispatching", {
       agentId: agentConfig.id,
       fromScope: payload.fromScopeKey,
       toScope: payload.toScopeKey,
@@ -2892,7 +3232,7 @@ var AgentManager = class {
     });
     if (existingProc && existingProc.status !== "dead") {
       if (existingProc.status === "ready" || existingProc.status === "starting") {
-        logger6.info("Neural send dispatched to idle runtime", {
+        logger7.info("Neural send dispatched to idle runtime", {
           agentId: agentConfig.id,
           toScope: payload.toScopeKey,
           replyMessageId: task.replyMessageId,
@@ -2903,7 +3243,7 @@ var AgentManager = class {
         const runtime = this.asRuntime(existingProc);
         runtime.inputController.push(task.content, runtime.ccSessionId ?? "");
         runtime.injectedTasks.push(task);
-        logger6.info("Neural send injected mid-turn", {
+        logger7.info("Neural send injected mid-turn", {
           agentId: agentConfig.id,
           toScope: payload.toScopeKey,
           replyMessageId: task.replyMessageId,
@@ -2915,7 +3255,7 @@ var AgentManager = class {
     let cwd;
     if (targetScope.kind === "group") {
       if (!payload.targetCwd) {
-        logger6.error("Neural send abort: group target missing targetCwd", {
+        logger7.error("Neural send abort: group target missing targetCwd", {
           agentId: agentConfig.id,
           toScope: payload.toScopeKey
         });
@@ -2923,10 +3263,10 @@ var AgentManager = class {
       }
       cwd = payload.targetCwd;
     } else {
-      cwd = agentConfig.workingDirectory || path6.join(this.workspacesDir, agentConfig.id);
+      cwd = agentConfig.workingDirectory || path7.join(this.workspacesDir, agentConfig.id);
     }
     void this.acquire(agentConfig, targetScope, cwd).then(() => {
-      logger6.info("Neural send new runtime acquired", {
+      logger7.info("Neural send new runtime acquired", {
         agentId: agentConfig.id,
         toScope: payload.toScopeKey,
         cwd,
@@ -2934,7 +3274,7 @@ var AgentManager = class {
       });
       return this.sendMessage({ ...task, agentId: agentConfig.id, scope: targetScope });
     }).catch((err) => {
-      logger6.error("Neural send acquire failed", {
+      logger7.error("Neural send acquire failed", {
         agentId: agentConfig.id,
         toScope: payload.toScopeKey,
         cwd,
@@ -2950,7 +3290,7 @@ var AgentManager = class {
       (k) => k === agentId || k.startsWith(`${agentId}::`)
     );
     if (keys.length === 0) {
-      logger6.warn("terminate: no process for agent", { agentId });
+      logger7.warn("terminate: no process for agent", { agentId });
       this.sessionStore.deleteAllForAgent(agentId);
       return;
     }
@@ -2961,19 +3301,19 @@ var AgentManager = class {
       }
     }
     this.sessionStore.deleteAllForAgent(agentId);
-    logger6.info("terminate: all scoped queries removed", { agentId, count: keys.length });
+    logger7.info("terminate: all scoped queries removed", { agentId, count: keys.length });
   }
   /** Stop one scoped SDK runtime (workdir change). */
   async terminateScope(agentId, scope) {
     const key = runtimeKey(agentId, scope);
     const proc = this.agents.get(key);
     if (!proc) {
-      logger6.info("terminateScope: no active runtime", { agentId, scope: scopeKey(scope) });
+      logger7.info("terminateScope: no active runtime", { agentId, scope: scopeKey(scope) });
       return;
     }
     await this.closeRuntime(proc, "terminateScope");
     this.sessionStore.delete(agentId, scope);
-    logger6.info("terminateScope: scoped query removed", { agentId, scope: scopeKey(scope) });
+    logger7.info("terminateScope: scoped query removed", { agentId, scope: scopeKey(scope) });
   }
   async closeRuntime(proc, reason) {
     const key = runtimeKey(proc.agentId, proc.scope);
@@ -3003,7 +3343,7 @@ var AgentManager = class {
     runtime.mergedTasks = [];
     for (const t of mergedAtClose) {
       if (runtime.currentTask) {
-        logger6.info("Emitting agent:merged on runtime close", {
+        logger7.info("Emitting agent:merged on runtime close", {
           agentId: runtime.agentId,
           replyMessageId: t.replyMessageId,
           mergedInto: runtime.currentTask.replyMessageId,
@@ -3030,45 +3370,57 @@ var AgentManager = class {
       runtime.inputController.close();
       await this.awaitQueryReturn(runtime.query, 5e3, agentId);
     } catch (e) {
-      logger6.error(`${reason}: close query failed`, { agentId, scope: scopeKey(proc.scope), error: e });
+      logger7.error(`${reason}: close query failed`, { agentId, scope: scopeKey(proc.scope), error: e });
     }
     proc.status = "dead";
     this.agents.delete(key);
     this.lastUsedAt.delete(key);
-    logger6.info(`${reason}: keeping workspace dir intact (per project policy)`, {
+    logger7.info(`${reason}: keeping workspace dir intact (per project policy)`, {
       agentId,
       scope: scopeKey(proc.scope),
       cwd: proc.cwd
     });
   }
   async recoverFromRestart(agents) {
-    logger6.info("Recovering Agent sessions after restart", { count: agents.length });
+    logger7.info("Recovering Agent sessions after restart", { count: agents.length });
     const agentsWithSession = agents.filter((a) => {
       const sessionId = this.sessionStore.get(a.id, { kind: "single" });
       return !!sessionId;
     });
     if (agentsWithSession.length === 0) {
-      logger6.info("No Agent sessions to recover");
+      logger7.info("No Agent sessions to recover");
       return;
     }
     let warmed = 0;
     const cap = this.queryConfig.maxActive;
     for (const agent of agentsWithSession) {
       if (warmed >= cap) {
-        logger6.info("Recovery warm cap reached", { cap, skipped: agentsWithSession.length - warmed });
+        logger7.info("Recovery warm cap reached", { cap, skipped: agentsWithSession.length - warmed });
         break;
       }
       try {
-        const cwd = agent.workingDirectory || path6.join(this.workspacesDir, agent.id);
+        let cwd = agent.workingDirectory || path7.join(this.workspacesDir, agent.id);
+        if (agent.workingDirectory) {
+          try {
+            await fs3.mkdir(cwd, { recursive: true });
+          } catch {
+            cwd = path7.join(this.workspacesDir, agent.id);
+            logger7.warn("Stored workingDirectory inaccessible, falling back", {
+              agentId: agent.id,
+              stored: agent.workingDirectory,
+              fallback: cwd
+            });
+          }
+        }
         await this.acquire(agent, { kind: "single" }, cwd);
         warmed++;
-        logger6.info("Agent process pre-created for recovery", { agentId: agent.id });
+        logger7.info("Agent process pre-created for recovery", { agentId: agent.id });
       } catch (err) {
         if (err instanceof BridgeBusyError) {
-          logger6.warn("Recovery stopped: bridge busy", { agentId: agent.id });
+          logger7.warn("Recovery stopped: bridge busy", { agentId: agent.id });
           break;
         }
-        logger6.warn("Failed to pre-create Agent for recovery, clearing session", {
+        logger7.warn("Failed to pre-create Agent for recovery, clearing session", {
           agentId: agent.id,
           error: err
         });
@@ -3092,7 +3444,7 @@ var AgentManager = class {
     } catch (err) {
       const errMsg = err.message ?? String(err);
       const isResumeFail = /session|conversation.*not found/i.test(errMsg);
-      logger6.error("Agent query stream ended with error", {
+      logger7.error("Agent query stream ended with error", {
         agentId: runtime.agentId,
         scope: scopeKey(runtime.scope),
         isResumeFail,
@@ -3100,7 +3452,7 @@ var AgentManager = class {
         error: err
       });
       this.sessionStore.delete(runtime.agentId, runtime.scope);
-      logger6.info("Cleared stale session after query crash", {
+      logger7.info("Cleared stale session after query crash", {
         agentId: runtime.agentId,
         scope: scopeKey(runtime.scope)
       });
@@ -3161,8 +3513,50 @@ var AgentManager = class {
     }
     return [...ids];
   }
+  /**
+   * Push a system notice to ALL active runtimes of the given agent.
+   *
+   * Working runtimes: injected mid-turn via InputController (merged into
+   * the current turn, no extra result expected).
+   * Ready/starting runtimes: dispatched as a lightweight task so any SDK
+   * output has valid replyMessageId/conversationId to land on.
+   */
+  broadcastScopeNotice(agentId, notice) {
+    let notified = 0;
+    for (const [, proc] of this.agents) {
+      if (proc.agentId !== agentId || proc.status === "dead") continue;
+      const runtime = this.asRuntime(proc);
+      if (proc.status === "working") {
+        runtime.inputController.push(notice, runtime.ccSessionId ?? "");
+        logger7.info("Scope notice injected mid-turn", {
+          agentId,
+          scope: scopeKey(proc.scope),
+          noticeLen: notice.length
+        });
+      } else if (proc.status === "ready" || proc.status === "starting") {
+        const task = {
+          content: notice,
+          replyMessageId: `msg_scopenotice_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
+          conversationId: proc.currentTask?.conversationId ?? "",
+          traceId: `tr_scopenotice_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
+          groupId: proc.scope.kind === "group" ? proc.scope.groupId : void 0
+        };
+        this.dispatchToSDK(runtime, task);
+        logger7.info("Scope notice dispatched to idle runtime", {
+          agentId,
+          scope: scopeKey(proc.scope),
+          replyMessageId: task.replyMessageId
+        });
+      }
+      notified++;
+    }
+    logger7.info("broadcastScopeNotice completed", {
+      agentId,
+      notifiedCount: notified
+    });
+  }
   async shutdownAll() {
-    logger6.info("Shutting down all Agent processes", { count: this.agents.size });
+    logger7.info("Shutting down all Agent processes", { count: this.agents.size });
     this.askQuestionRegistry.cancelAll("agent_aborted");
     if (this.evictionTimer) {
       clearInterval(this.evictionTimer);
@@ -3174,9 +3568,9 @@ var AgentManager = class {
         runtime.inputController?.close();
         runtime.query?.return(void 0);
         proc.status = "dead";
-        logger6.info("Agent process shut down", { agentId: proc.agentId, scope: scopeKey(proc.scope), key });
+        logger7.info("Agent process shut down", { agentId: proc.agentId, scope: scopeKey(proc.scope), key });
       } catch (err) {
-        logger6.error("Error shutting down Agent", { agentId: proc.agentId, error: err });
+        logger7.error("Error shutting down Agent", { agentId: proc.agentId, error: err });
       }
     }
     this.agents.clear();
@@ -3193,13 +3587,13 @@ var AgentManager = class {
       }
     }
     if (!proc) {
-      logger6.warn("cancelReply: no active process for reply", { agentId, replyMessageId });
+      logger7.warn("cancelReply: no active process for reply", { agentId, replyMessageId });
       return;
     }
     const runtime = this.asRuntime(proc);
     const key = runtimeKey(agentId, proc.scope);
     if (!runtime.currentTask || runtime.currentTask.replyMessageId !== replyMessageId) {
-      logger6.warn("cancelReply: replyMessageId mismatch", {
+      logger7.warn("cancelReply: replyMessageId mismatch", {
         agentId,
         replyMessageId,
         expected: runtime.currentTask?.replyMessageId
@@ -3228,7 +3622,7 @@ var AgentManager = class {
     proc.status = "dead";
     this.agents.delete(key);
     this.lastUsedAt.delete(key);
-    logger6.info("cancelReply: process torn down", {
+    logger7.info("cancelReply: process torn down", {
       agentId,
       scope: scopeKey(proc.scope),
       conversationId,
@@ -3237,10 +3631,10 @@ var AgentManager = class {
     try {
       runtime.inputController.close();
     } catch (err) {
-      logger6.error("cancelReply: inputController.close failed", { agentId, error: err });
+      logger7.error("cancelReply: inputController.close failed", { agentId, error: err });
     }
     runtime.query.return(void 0).catch((err) => {
-      logger6.warn("cancelReply: query.return threw", { agentId, error: err });
+      logger7.warn("cancelReply: query.return threw", { agentId, error: err });
     });
   }
 };
@@ -3257,7 +3651,7 @@ function buildInnerVoiceEnvelope(payload) {
 }
 
 // src/agentRegistry.ts
-var logger7 = createModuleLogger("agent.registry");
+var logger8 = createModuleLogger("agent.registry");
 var HttpAgentRegistry = class {
   constructor(serverApiUrl) {
     this.serverApiUrl = serverApiUrl;
@@ -3266,8 +3660,8 @@ var HttpAgentRegistry = class {
   agents = /* @__PURE__ */ new Map();
   apiUrl(suffix) {
     const base = this.serverApiUrl.replace(/\/$/, "");
-    const path10 = suffix.startsWith("/") ? suffix : `/${suffix}`;
-    return `${base}${path10}`;
+    const path12 = suffix.startsWith("/") ? suffix : `/${suffix}`;
+    return `${base}${path12}`;
   }
   async refresh() {
     const attempt = async () => {
@@ -3285,17 +3679,17 @@ var HttpAgentRegistry = class {
       recoveredAfterRetry = res != null;
     }
     if (!res) {
-      logger7.warn("Agent registry refresh unreachable after retry, keeping cache");
+      logger8.warn("Agent registry refresh unreachable after retry, keeping cache");
       return;
     }
     if (!res.ok) {
-      logger7.warn("Agent registry refresh failed", { status: res.status });
+      logger8.warn("Agent registry refresh failed", { status: res.status });
       return;
     }
     try {
       const body = await res.json();
       if (!Array.isArray(body)) {
-        logger7.warn("Agent registry refresh: expected array");
+        logger8.warn("Agent registry refresh: expected array");
         return;
       }
       this.agents.clear();
@@ -3305,9 +3699,9 @@ var HttpAgentRegistry = class {
           this.agents.set(a.id, a);
         }
       }
-      logger7.info("Agent registry refreshed", { count: this.agents.size, recoveredAfterRetry });
+      logger8.info("Agent registry refreshed", { count: this.agents.size, recoveredAfterRetry });
     } catch (e) {
-      logger7.warn("Agent registry refresh parse failed", { error: e });
+      logger8.warn("Agent registry refresh parse failed", { error: e });
     }
   }
   getById(id) {
@@ -3321,17 +3715,17 @@ var HttpAgentRegistry = class {
     try {
       const res = await fetch(this.apiUrl(`/api/agents/${encodeURIComponent(id)}`));
       if (!res.ok) {
-        logger7.warn("fetchById failed", { agentId: id, status: res.status });
+        logger8.warn("fetchById failed", { agentId: id, status: res.status });
         return null;
       }
       const agent = await res.json();
       if (agent && typeof agent.id === "string") {
         this.agents.set(agent.id, agent);
-        logger7.info("Agent registry fetchById upserted", { agentId: id });
+        logger8.info("Agent registry fetchById upserted", { agentId: id });
       }
       return agent;
     } catch (e) {
-      logger7.warn("fetchById unreachable", { agentId: id, error: e });
+      logger8.warn("fetchById unreachable", { agentId: id, error: e });
       return null;
     }
   }
@@ -3340,16 +3734,16 @@ var HttpAgentRegistry = class {
   }
   upsert(agent) {
     this.agents.set(agent.id, agent);
-    logger7.debug("Agent registry upsert", { agentId: agent.id });
+    logger8.debug("Agent registry upsert", { agentId: agent.id });
   }
   remove(agentId) {
     this.agents.delete(agentId);
-    logger7.debug("Agent registry remove", { agentId });
+    logger8.debug("Agent registry remove", { agentId });
   }
 };
 
 // src/groupRegistry.ts
-var logger8 = createModuleLogger("neural.groupRegistry");
+var logger9 = createModuleLogger("neural.groupRegistry");
 var GroupRegistry = class {
   groups = /* @__PURE__ */ new Map();
   serverApiUrl;
@@ -3372,17 +3766,17 @@ var GroupRegistry = class {
       recoveredAfterRetry = res != null;
     }
     if (!res) {
-      logger8.warn("GroupRegistry refresh unreachable after retry");
+      logger9.warn("GroupRegistry refresh unreachable after retry");
       return;
     }
     if (!res.ok) {
-      logger8.warn("GroupRegistry refresh failed", { status: res.status });
+      logger9.warn("GroupRegistry refresh failed", { status: res.status });
       return;
     }
     try {
       const body = await res.json();
       if (!Array.isArray(body)) {
-        logger8.warn("GroupRegistry refresh: expected array");
+        logger9.warn("GroupRegistry refresh: expected array");
         return;
       }
       this.groups.clear();
@@ -3397,14 +3791,25 @@ var GroupRegistry = class {
           });
         }
       }
-      logger8.info("GroupRegistry refreshed", { count: this.groups.size, recoveredAfterRetry });
+      logger9.info("GroupRegistry refreshed", { count: this.groups.size, recoveredAfterRetry });
     } catch (e) {
-      logger8.warn("GroupRegistry refresh parse failed", { error: e });
+      logger9.warn("GroupRegistry refresh parse failed", { error: e });
     }
   }
   getById(groupId) {
     return this.groups.get(groupId) ?? null;
   }
+  /**
+   * Return the cached groups that the given agent is a member of.
+   * Does NOT refresh — caller decides when to call refresh().
+   */
+  getMyGroups(agentId) {
+    const out = [];
+    for (const g of this.groups.values()) {
+      if (g.members.includes(agentId)) out.push(g);
+    }
+    return out;
+  }
   /**
    * Fuzzy match by name (case-insensitive substring).
    * Returns the first match.
@@ -3438,16 +3843,16 @@ var GroupRegistry = class {
     try {
       const res = await fetch(url);
       if (res.status === 404) {
-        logger8.info("GroupRegistry resolveScope: group not found", { rawScope, suffix });
+        logger9.info("GroupRegistry resolveScope: group not found", { rawScope, suffix });
         return null;
       }
       if (!res.ok) {
-        logger8.warn("GroupRegistry resolveScope: HTTP error", { rawScope, status: res.status });
+        logger9.warn("GroupRegistry resolveScope: HTTP error", { rawScope, status: res.status });
         return null;
       }
       const data = await res.json();
       if (!data.groupId || !data.conversationId || !data.workingDirectory) {
-        logger8.warn("GroupRegistry resolveScope: incomplete response", {
+        logger9.warn("GroupRegistry resolveScope: incomplete response", {
           rawScope,
           hasGroupId: !!data.groupId,
           hasConversationId: !!data.conversationId,
@@ -3455,7 +3860,7 @@ var GroupRegistry = class {
         });
         return null;
       }
-      logger8.info("GroupRegistry resolved scope", {
+      logger9.info("GroupRegistry resolved scope", {
         rawScope,
         resolvedGroupId: data.groupId,
         resolvedName: data.name ?? "(none)",
@@ -3470,7 +3875,7 @@ var GroupRegistry = class {
         workingDirectory: data.workingDirectory
       };
     } catch (e) {
-      logger8.error("GroupRegistry resolveScope error", { rawScope, error: e });
+      logger9.error("GroupRegistry resolveScope error", { rawScope, error: e });
       return null;
     }
   }
@@ -3491,12 +3896,12 @@ var GroupRegistry = class {
         if (Array.isArray(body)) {
           const single = body.find((c) => c.type === "single" && typeof c.id === "string");
           if (single?.id) {
-            logger8.info("GroupRegistry resolved single conv", { agentId, conversationId: single.id });
+            logger9.info("GroupRegistry resolved single conv", { agentId, conversationId: single.id });
             return single.id;
           }
         }
       } else {
-        logger8.warn("GroupRegistry resolveSingle: list failed", { agentId, status: res.status });
+        logger9.warn("GroupRegistry resolveSingle: list failed", { agentId, status: res.status });
       }
       const created = await fetch(`${this.serverApiUrl}/api/conversations`, {
         method: "POST",
@@ -3504,26 +3909,27 @@ var GroupRegistry = class {
         body: JSON.stringify({ agentId })
       });
       if (!created.ok) {
-        logger8.warn("GroupRegistry resolveSingle: create failed", { agentId, status: created.status });
+        logger9.warn("GroupRegistry resolveSingle: create failed", { agentId, status: created.status });
         return null;
       }
       const conv = await created.json();
       if (typeof conv.id !== "string") {
-        logger8.warn("GroupRegistry resolveSingle: created conv missing id", { agentId });
+        logger9.warn("GroupRegistry resolveSingle: created conv missing id", { agentId });
         return null;
       }
-      logger8.info("GroupRegistry created single conv", { agentId, conversationId: conv.id });
+      logger9.info("GroupRegistry created single conv", { agentId, conversationId: conv.id });
       return conv.id;
     } catch (e) {
-      logger8.error("GroupRegistry resolveSingle error", { agentId, error: e });
+      logger9.error("GroupRegistry resolveSingle error", { agentId, error: e });
       return null;
     }
   }
 };
 
 // src/connector.ts
+import os5 from "os";
 import WebSocket from "ws";
-var logger9 = createModuleLogger("ws.connector");
+var logger10 = createModuleLogger("ws.connector");
 var ServerConnector = class {
   ws = null;
   reconnectAttempts = 0;
@@ -3553,19 +3959,19 @@ var ServerConnector = class {
       url.searchParams.set("token", this.config.bridgeToken);
     }
     const wsUrl = url.toString();
-    logger9.info("Connecting to server", { url: this.config.serverUrl });
+    logger10.info("Connecting to server", { url: wsUrl });
     const ws = new WebSocket(wsUrl);
     ws.on("open", () => {
       this.ws = ws;
       this.reconnectAttempts = 0;
-      logger9.info("Connected to server", { url: this.config.serverUrl });
+      logger10.info("Connected to server", { url: this.config.serverUrl });
       void this.handleOpen();
     });
     ws.on("message", (data) => {
       this.handleMessage(data);
     });
     ws.on("close", (code, reason) => {
-      logger9.warn("Disconnected from server", {
+      logger10.warn("Disconnected from server", {
         code,
         reason: reason.toString()
       });
@@ -3575,15 +3981,15 @@ var ServerConnector = class {
       }
     });
     ws.on("error", (err) => {
-      logger9.error("WebSocket error", { error: err });
+      logger10.error("WebSocket error", { error: err });
     });
   }
   async handleOpen() {
     try {
       await this.onConnected();
-      logger9.info("Recovery complete, sending bridge:register");
+      logger10.info("Recovery complete, sending bridge:register");
     } catch (err) {
-      logger9.error("Recovery failed, registering with degraded state", { error: err });
+      logger10.error("Recovery failed, registering with degraded state", { error: err });
     }
     this.register();
   }
@@ -3595,13 +4001,14 @@ var ServerConnector = class {
       payload: {
         bridgeId: this.config.bridgeId,
         agents: ids,
+        hostname: os5.hostname(),
         queryConfig: {
           maxActive: qc.maxActive,
           idleTimeoutMs: qc.idleTimeoutMs
         }
       }
     });
-    logger9.info("Sent bridge:register", {
+    logger10.info("Sent bridge:register", {
       bridgeId: this.config.bridgeId,
       agents: ids
     });
@@ -3612,7 +4019,7 @@ var ServerConnector = class {
       const raw = typeof data === "string" ? data : data.toString("utf8");
       msg = parseWSMessage(raw);
     } catch (e) {
-      logger9.error("Invalid WS message from server", { error: e });
+      logger10.error("Invalid WS message from server", { error: e });
       return;
     }
     wsMetrics.incRecv(msg.type);
@@ -3623,7 +4030,7 @@ var ServerConnector = class {
       }
       case "task:dispatch": {
         void this.onTaskDispatch(msg.payload).catch((err) => {
-          logger9.error("Failed to handle task:dispatch", {
+          logger10.error("Failed to handle task:dispatch", {
             error: err,
             traceId: msg.payload.traceId
           });
@@ -3633,19 +4040,19 @@ var ServerConnector = class {
       case "task:group_dispatch": {
         if (this.onGroupTaskDispatch) {
           void this.onGroupTaskDispatch(msg.payload).catch((err) => {
-            logger9.error("Failed to handle task:group_dispatch", {
+            logger10.error("Failed to handle task:group_dispatch", {
               error: err,
               traceId: msg.payload.traceId
             });
           });
         } else {
-          logger9.warn("Received task:group_dispatch but no handler registered");
+          logger10.warn("Received task:group_dispatch but no handler registered");
         }
         return;
       }
       case "user:stop_generation": {
         void this.onStopGeneration(msg.payload).catch((err) => {
-          logger9.error("Failed to handle user:stop_generation", {
+          logger10.error("Failed to handle user:stop_generation", {
             error: err,
             traceId: msg.payload.traceId
           });
@@ -3659,16 +4066,17 @@ var ServerConnector = class {
       case "agent:updated":
       case "agent:deleted":
       case "group:member_changed":
+      case "group:updated":
       case "user:answer_question": {
         if (this.onServerPush) {
           void Promise.resolve(this.onServerPush(msg)).catch((err) => {
-            logger9.error("onServerPush handler failed", { error: err, type: msg.type });
+            logger10.error("onServerPush handler failed", { error: err, type: msg.type });
           });
         }
         return;
       }
       default: {
-        logger9.warn("Unhandled server message type", {
+        logger10.warn("Unhandled server message type", {
           type: msg.type
         });
       }
@@ -3676,7 +4084,7 @@ var ServerConnector = class {
   }
   send(msg) {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      logger9.warn("Cannot send: WebSocket not open", {
+      logger10.warn("Cannot send: WebSocket not open", {
         type: msg.type
       });
       return;
@@ -3685,14 +4093,14 @@ var ServerConnector = class {
       this.ws.send(JSON.stringify(msg));
       wsMetrics.incSend(msg.type);
     } catch (e) {
-      logger9.error("Failed to send WS message", { error: e, type: msg.type });
+      logger10.error("Failed to send WS message", { error: e, type: msg.type });
     }
   }
   scheduleReconnect() {
     if (this.closing) return;
     const delay = this.delays[Math.min(this.reconnectAttempts, this.delays.length - 1)];
     this.reconnectAttempts++;
-    logger9.info("Scheduling reconnect", {
+    logger10.info("Scheduling reconnect", {
       attempt: this.reconnectAttempts,
       delayMs: delay
     });
@@ -3708,11 +4116,11 @@ var ServerConnector = class {
       try {
         this.ws.close(1e3, "Bridge shutting down");
       } catch (e) {
-        logger9.error("Error closing WebSocket", { error: e });
+        logger10.error("Error closing WebSocket", { error: e });
       }
       this.ws = null;
     }
-    logger9.info("Connector closed");
+    logger10.info("Connector closed");
   }
   get isConnected() {
     return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
@@ -3720,14 +4128,14 @@ var ServerConnector = class {
 };
 
 // src/modelQuerier.ts
-import fs3 from "fs/promises";
-import os5 from "os";
-import path7 from "path";
-var logger10 = createModuleLogger("bridge.modelQuerier");
+import fs4 from "fs/promises";
+import os6 from "os";
+import path8 from "path";
+var logger11 = createModuleLogger("bridge.modelQuerier");
 async function listModels(queryFn, opts = {}) {
   const t0 = Date.now();
-  const cwd = opts.cwd ?? path7.join(os5.homedir(), ".ahchat", "workspaces", "_list_models");
-  await fs3.mkdir(cwd, { recursive: true });
+  const cwd = opts.cwd ?? path8.join(os6.homedir(), ".ahchat", "workspaces", "_list_models");
+  await fs4.mkdir(cwd, { recursive: true });
   const fn = queryFn ?? (await import("@anthropic-ai/claude-agent-sdk")).query;
   const ic = new InputController();
   ic.push("Reply with exactly: PING", "");
@@ -3769,7 +4177,7 @@ async function listModels(queryFn, opts = {}) {
       displayName: m.displayName,
       description: m.description
     }));
-    logger10.info("listModels done", { count: models.length, ms: Date.now() - t0 });
+    logger11.info("listModels done", { count: models.length, ms: Date.now() - t0 });
     return models;
   } finally {
     try {
@@ -3784,9 +4192,9 @@ async function listModels(queryFn, opts = {}) {
 }
 
 // src/lockfile.ts
-import fs4 from "fs";
-import path8 from "path";
-var logger11 = createModuleLogger("bridge.lockfile");
+import fs5 from "fs";
+import path9 from "path";
+var logger12 = createModuleLogger("bridge.lockfile");
 var lockPath = null;
 function isProcessAlive(pid) {
   try {
@@ -3799,32 +4207,32 @@ function isProcessAlive(pid) {
   }
 }
 function acquireLock(dataDir) {
-  const file = path8.join(dataDir, "bridge.lock");
+  const file = path9.join(dataDir, "bridge.lock");
   lockPath = file;
-  if (fs4.existsSync(file)) {
-    const raw = fs4.readFileSync(file, "utf-8").trim();
+  if (fs5.existsSync(file)) {
+    const raw = fs5.readFileSync(file, "utf-8").trim();
     const pid = Number.parseInt(raw, 10);
     if (Number.isFinite(pid) && pid > 0) {
       if (isProcessAlive(pid)) {
         throw new Error(`Bridge already running (PID: ${pid})`);
       }
-      logger11.warn("Removing stale bridge.lock (process not found)", { pid, path: file });
+      logger12.warn("Removing stale bridge.lock (process not found)", { pid, path: file });
     }
   }
-  fs4.mkdirSync(path8.dirname(file), { recursive: true });
-  fs4.writeFileSync(file, String(process.pid), "utf-8");
-  logger11.info("Acquired bridge lock", { path: file, pid: process.pid });
+  fs5.mkdirSync(path9.dirname(file), { recursive: true });
+  fs5.writeFileSync(file, String(process.pid), "utf-8");
+  logger12.info("Acquired bridge lock", { path: file, pid: process.pid });
   const release = () => {
     try {
-      if (lockPath && fs4.existsSync(lockPath)) {
-        const current = fs4.readFileSync(lockPath, "utf-8").trim();
+      if (lockPath && fs5.existsSync(lockPath)) {
+        const current = fs5.readFileSync(lockPath, "utf-8").trim();
         if (current === String(process.pid)) {
-          fs4.unlinkSync(lockPath);
-          logger11.info("Released bridge lock", { path: lockPath });
+          fs5.unlinkSync(lockPath);
+          logger12.info("Released bridge lock", { path: lockPath });
         }
       }
     } catch (e) {
-      logger11.error("Failed to release bridge lock", { error: e, path: lockPath });
+      logger12.error("Failed to release bridge lock", { error: e, path: lockPath });
     } finally {
       lockPath = null;
     }
@@ -3927,9 +4335,9 @@ function buildGroupPrompt(payload) {
 }
 
 // src/messageHandler.ts
-var logger12 = createModuleLogger("msg.handler");
+var logger13 = createModuleLogger("msg.handler");
 function emitTaskAck(emit, ackId, agentId, traceId) {
-  logger12.info("Emitting task:ack", { ackId, agentId, traceId });
+  logger13.info("Emitting task:ack", { ackId, agentId, traceId });
   emit({
     type: "task:ack",
     payload: {
@@ -3942,7 +4350,7 @@ function emitTaskAck(emit, ackId, agentId, traceId) {
 }
 function createTaskDispatchHandler(agentManager, agentRegistry, emit) {
   return async (payload) => {
-    logger12.info("Handling task:dispatch", {
+    logger13.info("Handling task:dispatch", {
       agentId: payload.agentId,
       messageId: payload.messageId,
       ackId: payload.ackId,
@@ -3951,14 +4359,14 @@ function createTaskDispatchHandler(agentManager, agentRegistry, emit) {
     emitTaskAck(emit, payload.ackId, payload.agentId, payload.traceId);
     let agentConfig = agentRegistry.getById(payload.agentId);
     if (!agentConfig) {
-      logger12.warn("Agent not in registry, attempting live fetch", {
+      logger13.warn("Agent not in registry, attempting live fetch", {
         agentId: payload.agentId,
         traceId: payload.traceId
       });
       agentConfig = await agentRegistry.fetchById(payload.agentId);
     }
     if (!agentConfig) {
-      logger12.error("Agent not found for task:dispatch (after live fetch)", {
+      logger13.error("Agent not found for task:dispatch (after live fetch)", {
         agentId: payload.agentId,
         traceId: payload.traceId
       });
@@ -3985,7 +4393,7 @@ function createTaskDispatchHandler(agentManager, agentRegistry, emit) {
         traceId: payload.traceId
       });
     } catch (err) {
-      logger12.error("Failed to dispatch message to Agent", {
+      logger13.error("Failed to dispatch message to Agent", {
         error: err,
         agentId: payload.agentId,
         traceId: payload.traceId
@@ -4005,7 +4413,7 @@ function createTaskDispatchHandler(agentManager, agentRegistry, emit) {
 }
 function createGroupTaskDispatchHandler(agentManager, agentRegistry, emit) {
   return async (payload) => {
-    logger12.info("Handling task:group_dispatch", {
+    logger13.info("Handling task:group_dispatch", {
       agentId: payload.agentId,
       groupId: payload.groupId,
       ackId: payload.ackId,
@@ -4017,14 +4425,14 @@ function createGroupTaskDispatchHandler(agentManager, agentRegistry, emit) {
     emitTaskAck(emit, payload.ackId, payload.agentId, payload.traceId);
     let agentConfig = agentRegistry.getById(payload.agentId);
     if (!agentConfig) {
-      logger12.warn("Agent not in registry for group dispatch, attempting live fetch", {
+      logger13.warn("Agent not in registry for group dispatch, attempting live fetch", {
         agentId: payload.agentId,
         traceId: payload.traceId
       });
       agentConfig = await agentRegistry.fetchById(payload.agentId);
     }
     if (!agentConfig) {
-      logger12.error("Agent not found for task:group_dispatch (after live fetch)", {
+      logger13.error("Agent not found for task:group_dispatch (after live fetch)", {
         agentId: payload.agentId,
         traceId: payload.traceId
       });
@@ -4057,7 +4465,7 @@ function createGroupTaskDispatchHandler(agentManager, agentRegistry, emit) {
         groupId: payload.groupId
       });
     } catch (err) {
-      logger12.error("Failed to dispatch group message to Agent", {
+      logger13.error("Failed to dispatch group message to Agent", {
         error: err,
         agentId: payload.agentId,
         groupId: payload.groupId,
@@ -4077,15 +4485,84 @@ function createGroupTaskDispatchHandler(agentManager, agentRegistry, emit) {
   };
 }
 
+// src/scopePushNotify.ts
+var logger14 = createModuleLogger("bridge");
+function buildMemberChangedScopeNotice(params) {
+  const { groupId, groupLabel, action } = params;
+  const verb = action === "added" ? "\u52A0\u5165" : "\u79FB\u51FA";
+  return [
+    `[\u7CFB\u7EDF\u901A\u77E5] \u4F60\u5DF2\u88AB${verb}\u7FA4\u300C${groupLabel}\u300D(group:${groupId})\u3002`,
+    `\u4F60\u7684\u53EF\u8FBE scope \u5DF2\u53D8\u66F4\u3002\u4E0B\u6B21\u4F7F\u7528 neural_send \u524D\u8BF7\u4EE5\u6B64\u4E3A\u51C6\uFF0C\u6216\u8C03 neural_list_scopes() \u786E\u8BA4\u6700\u65B0\u5217\u8868\u3002`,
+    `\u65E0\u9700\u56DE\u590D\u6B64\u901A\u77E5\u3002`
+  ].join("\n");
+}
+function buildGroupRenamedScopeNotice(params) {
+  const { groupId, newName } = params;
+  return [
+    `[\u7CFB\u7EDF\u901A\u77E5] \u7FA4 (group:${groupId}) \u5DF2\u66F4\u540D\u4E3A\u300C${newName}\u300D\u3002`,
+    `\u82E5\u4F60\u4E4B\u524D\u7528\u65E7\u7FA4\u540D\u8C03\u8FC7 neural_send\uFF0C\u8BF7\u66F4\u65B0\u4E3A\u65B0\u540D\u79F0\u3002`,
+    `\u65E0\u9700\u56DE\u590D\u6B64\u901A\u77E5\u3002`
+  ].join("\n");
+}
+async function handleGroupMemberChangedPush(deps, payload) {
+  const { groupId, action, agentId } = payload;
+  logger14.info("group:member_changed received, refreshing GroupRegistry", {
+    groupId,
+    action,
+    agentId
+  });
+  await deps.groupRegistry.refresh();
+  logger14.info("GroupRegistry refreshed after member_changed", {
+    groupId,
+    action,
+    registryGroupCount: deps.groupRegistry.getAll().length
+  });
+  const group = deps.groupRegistry.getById(groupId);
+  const groupLabel = group?.name ?? groupId;
+  const notice = buildMemberChangedScopeNotice({ groupId, groupLabel, action });
+  deps.agentManager.broadcastScopeNotice(agentId, notice);
+  logger14.info("Scope notice sent for member_changed", {
+    agentId,
+    groupId,
+    groupLabel,
+    action,
+    noticeLen: notice.length
+  });
+}
+async function handleGroupUpdatedPush(deps, payload) {
+  const { groupId, name: newName, memberAgentIds } = payload;
+  logger14.info("group:updated received, refreshing GroupRegistry", {
+    groupId,
+    newName,
+    memberCount: memberAgentIds.length
+  });
+  await deps.groupRegistry.refresh();
+  logger14.info("GroupRegistry refreshed after group:updated", {
+    groupId,
+    newName,
+    registryGroupCount: deps.groupRegistry.getAll().length
+  });
+  const notice = buildGroupRenamedScopeNotice({ groupId, newName });
+  for (const aid of memberAgentIds) {
+    deps.agentManager.broadcastScopeNotice(aid, notice);
+  }
+  logger14.info("Scope notices sent for group:updated", {
+    groupId,
+    newName,
+    memberCount: memberAgentIds.length,
+    noticeLen: notice.length
+  });
+}
+
 // src/sessionStore.ts
-import fs5 from "fs";
-import path9 from "path";
-var logger13 = createModuleLogger("session.store");
+import fs6 from "fs";
+import path10 from "path";
+var logger15 = createModuleLogger("session.store");
 var SessionStore = class {
   filePath;
   cache;
   constructor(dataDir) {
-    this.filePath = path9.join(dataDir, "sessions.json");
+    this.filePath = path10.join(dataDir, "sessions.json");
     this.cache = this.loadFromDisk();
   }
   cacheKey(agentId, scope) {
@@ -4120,8 +4597,8 @@ var SessionStore = class {
   }
   loadFromDisk() {
     try {
-      if (!fs5.existsSync(this.filePath)) return {};
-      const raw = fs5.readFileSync(this.filePath, "utf-8");
+      if (!fs6.existsSync(this.filePath)) return {};
+      const raw = fs6.readFileSync(this.filePath, "utf-8");
       const parsed = JSON.parse(raw);
       if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
       const map = parsed;
@@ -4131,7 +4608,7 @@ var SessionStore = class {
           migrated[key] = sessionId;
         } else {
           migrated[`${key}::single`] = sessionId;
-          logger13.info("Migrated legacy session key to scoped key", {
+          logger15.info("Migrated legacy session key to scoped key", {
             legacyKey: key,
             newKey: `${key}::single`
           });
@@ -4139,29 +4616,29 @@ var SessionStore = class {
       }
       return migrated;
     } catch (e) {
-      logger13.warn("Failed to load sessions file, starting fresh", { error: e, path: this.filePath });
+      logger15.warn("Failed to load sessions file, starting fresh", { error: e, path: this.filePath });
       return {};
     }
   }
   saveToDisk() {
     try {
-      const dir = path9.dirname(this.filePath);
-      fs5.mkdirSync(dir, { recursive: true });
-      fs5.writeFileSync(this.filePath, JSON.stringify(this.cache, null, 2), "utf-8");
+      const dir = path10.dirname(this.filePath);
+      fs6.mkdirSync(dir, { recursive: true });
+      fs6.writeFileSync(this.filePath, JSON.stringify(this.cache, null, 2), "utf-8");
     } catch (e) {
-      logger13.error("Failed to save sessions file", { error: e, path: this.filePath });
+      logger15.error("Failed to save sessions file", { error: e, path: this.filePath });
     }
   }
 };
 
 // src/start.ts
-var logger14 = createModuleLogger("bridge");
+var logger16 = createModuleLogger("bridge");
 async function startBridge(config) {
   ensureDir(config.dataDir);
   ensureDir(config.claudeConfigDir);
   process.env.CLAUDE_CONFIG_DIR = config.claudeConfigDir;
   acquireLock(config.dataDir);
-  logger14.info("Bridge starting", {
+  logger16.info("Bridge starting", {
     bridgeId: config.bridgeId,
     serverUrl: config.serverUrl,
     serverApiUrl: config.serverApiUrl,
@@ -4169,6 +4646,9 @@ async function startBridge(config) {
   });
   wsMetrics.start(5e3);
   const sessionStore = new SessionStore(config.dataDir);
+  const memoryRoot = path11.join(config.dataDir, "agent-memory");
+  const memoryStore = new AgentMemoryStore(memoryRoot);
+  logger16.info("Agent memory store initialized", { rootDir: memoryRoot });
   const agentRegistry = new HttpAgentRegistry(config.serverApiUrl);
   const groupRegistry = new GroupRegistry(config.serverApiUrl);
   await agentRegistry.refresh();
@@ -4182,7 +4662,8 @@ async function startBridge(config) {
     queryConfig: config.queryConfig,
     claudeConfigDir: config.claudeConfigDir,
     askQuestionRegistry,
-    groupRegistry
+    groupRegistry,
+    memoryStore
   });
   const taskDispatchHandler = createTaskDispatchHandler(agentManager, agentRegistry, emit);
   const groupTaskDispatchHandler = createGroupTaskDispatchHandler(agentManager, agentRegistry, emit);
@@ -4204,21 +4685,21 @@ async function startBridge(config) {
       switch (msg.type) {
         case "bridge:list_models_request": {
           const { requestId } = msg.payload;
-          logger14.info("list_models request received", { requestId });
+          logger16.info("list_models request received", { requestId });
           try {
             const models = await listModels();
             connector?.send({
               type: "bridge:list_models_response",
               payload: { requestId, models }
             });
-            logger14.info("list_models response sent", { requestId, count: models.length });
+            logger16.info("list_models response sent", { requestId, count: models.length });
           } catch (e) {
             const err = e instanceof Error ? e.message : String(e);
             connector?.send({
               type: "bridge:list_models_response",
               payload: { requestId, error: err }
             });
-            logger14.error("list_models failed", { requestId, error: e });
+            logger16.error("list_models failed", { requestId, error: e });
           }
           break;
         }
@@ -4226,7 +4707,7 @@ async function startBridge(config) {
           await agentManager.terminate(msg.payload.agentId);
           break;
         case "agent:terminate_scope":
-          logger14.info("agent:terminate_scope received", {
+          logger16.info("agent:terminate_scope received", {
             agentId: msg.payload.agentId,
             scope: msg.payload.scope
           });
@@ -4239,11 +4720,31 @@ async function startBridge(config) {
         case "agent:deleted":
           agentRegistry.remove(msg.payload.agentId);
           break;
+        case "group:member_changed":
+          await handleGroupMemberChangedPush(
+            { groupRegistry, agentManager },
+            {
+              groupId: msg.payload.groupId,
+              action: msg.payload.action,
+              agentId: msg.payload.agentId
+            }
+          );
+          break;
+        case "group:updated":
+          await handleGroupUpdatedPush(
+            { groupRegistry, agentManager },
+            {
+              groupId: msg.payload.groupId,
+              name: msg.payload.name,
+              memberAgentIds: msg.payload.memberAgentIds
+            }
+          );
+          break;
         case "user:answer_question": {
           const p = msg.payload;
           const answerText = formatAnswerForSDK(p);
           const ok = askQuestionRegistry.resolve(p.questionId, answerText);
-          logger14.info("user:answer_question handled", {
+          logger16.info("user:answer_question handled", {
             questionId: p.questionId,
             agentId: p.agentId,
             resolved: ok,
@@ -4264,7 +4765,7 @@ async function startBridge(config) {
     });
   }, config.queryConfig.statusReportIntervalMs);
   const shutdown = async (signal) => {
-    logger14.info("Shutdown signal received", { signal });
+    logger16.info("Shutdown signal received", { signal });
     if (statusInterval) {
       clearInterval(statusInterval);
       statusInterval = null;
@@ -4272,7 +4773,7 @@ async function startBridge(config) {
     wsMetrics.stop();
     connector?.close();
     await agentManager.shutdownAll();
-    logger14.info("Bridge stopped");
+    logger16.info("Bridge stopped");
     process.exit(0);
   };
   process.on("SIGINT", () => void shutdown("SIGINT"));
@@ -4280,8 +4781,8 @@ async function startBridge(config) {
 }
 
 // src/index.ts
-var logger15 = createModuleLogger("bridge");
+var logger17 = createModuleLogger("bridge");
 void startBridge(loadBridgeConfig()).catch((e) => {
-  logger15.error("Bridge failed to start", { error: e });
+  logger17.error("Bridge failed to start", { error: e });
   process.exit(1);
 });