@botcord/daemon 0.2.66 → 0.2.68

package/dist/index.js

@@ -3,6 +3,7 @@ import { spawn } from "node:child_process";
 import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync, statSync, rmSync } from "node:fs";
 import { homedir, hostname } from "node:os";
 import path from "node:path";
+import { augmentProcessPath } from "./path-env.js";
 import { loadConfig, saveConfig, initDefaultConfig, resolveConfiguredAgentIds, PID_PATH, SNAPSHOT_PATH, CONFIG_FILE_PATH, CONFIG_MISSING, } from "./config.js";
 import { resolveBootAgents } from "./agent-discovery.js";
 import { defaultTranscriptRoot, resolveTranscriptEnabled, transcriptAgentRoot, transcriptFilePath, } from "./gateway/index.js";
@@ -18,6 +19,7 @@ import { clearWorkingMemory, readWorkingMemory, resolveMemoryDir, updateWorkingM
 import { createDiagnosticBundle } from "./diagnostics.js";
 import { resolveStartAuthAction } from "./start-auth.js";
 import { discoverLocalOpenclawGateways, mergeOpenclawGateways, openclawDiscoveryConfigEnabled, } from "./openclaw-discovery.js";
+augmentProcessPath();
 const ADAPTER_LIST = listAdapterIds().join("|");
 const DEFAULT_HUB = "https://api.botcord.chat";
 /**

package/dist/loop-risk.js

@@ -62,12 +62,26 @@ export function stripBotCordPromptScaffolding(text) {
             return false;
         if (line.startsWith("[Room Rule]"))
             return false;
-        if (line.startsWith("[In group chats, do NOT reply"))
+        if (line.startsWith("[In group chats,"))
+            return false;
+        if (line.startsWith("This group-reply restriction"))
+            return false;
+        if (line.startsWith("including analyzing the message"))
+            return false;
+        if (line.startsWith("forwarding a summary"))
+            return false;
+        if (line.startsWith("When a message matches an active monitoring rule"))
+            return false;
+        if (line.startsWith("keyword, sender rule"))
+            return false;
+        if (line.startsWith("you do not reply to the group"))
             return false;
         if (line.startsWith("[If the conversation has naturally concluded"))
             return false;
         if (line.startsWith("[You received a contact request"))
             return false;
+        if (line.includes("no background action is needed"))
+            return false;
         if (line.includes('reply with exactly "NO_REPLY"'))
             return false;
         if (line.startsWith("<agent-message"))

package/dist/path-env.d.ts

@@ -0,0 +1,8 @@
+export declare function commonDaemonPathEntries(home?: string | undefined): string[];
+export declare function mergePathEntries(basePath: string | undefined, extras: string[]): string;
+/**
+ * GUI-launched macOS apps inherit a sparse launchd PATH and do not read the
+ * user's shell profile. Add common per-user CLI install locations so runtime
+ * adapters can find tools installed by uv/pipx, cargo, bun, npm, etc.
+ */
+export declare function augmentProcessPath(): void;

package/dist/path-env.js

@@ -0,0 +1,43 @@
+import path from "node:path";
+const COMMON_USER_BIN_RELATIVE_PATHS = [
+    ".botcord/bin",
+    ".local/bin",
+    ".cargo/bin",
+    ".bun/bin",
+    ".deno/bin",
+    ".npm-global/bin",
+    ".yarn/bin",
+    ".pnpm",
+    ".pyenv/shims",
+    ".rye/shims",
+    ".pixi/bin",
+];
+const COMMON_SYSTEM_BIN_PATHS = process.platform === "darwin"
+    ? ["/opt/homebrew/bin", "/opt/homebrew/sbin", "/usr/local/bin", "/usr/local/sbin"]
+    : ["/usr/local/bin", "/usr/local/sbin"];
+export function commonDaemonPathEntries(home = process.env.HOME) {
+    const userEntries = home
+        ? COMMON_USER_BIN_RELATIVE_PATHS.map((entry) => path.join(home, entry))
+        : [];
+    return [...COMMON_SYSTEM_BIN_PATHS, ...userEntries];
+}
+export function mergePathEntries(basePath, extras) {
+    const seen = new Set();
+    const out = [];
+    for (const raw of [...(basePath ?? "").split(path.delimiter), ...extras]) {
+        const entry = raw.trim();
+        if (!entry || seen.has(entry))
+            continue;
+        seen.add(entry);
+        out.push(entry);
+    }
+    return out.join(path.delimiter);
+}
+/**
+ * GUI-launched macOS apps inherit a sparse launchd PATH and do not read the
+ * user's shell profile. Add common per-user CLI install locations so runtime
+ * adapters can find tools installed by uv/pipx, cargo, bun, npm, etc.
+ */
+export function augmentProcessPath() {
+    process.env.PATH = mergePathEntries(process.env.PATH, commonDaemonPathEntries(process.env.HOME));
+}

package/dist/turn-text.d.ts

@@ -15,9 +15,11 @@
  *   hello
  *   </agent-message>
  *
- *   [In group chats, do NOT reply unless you are explicitly mentioned or
- *    addressed. If no response is needed, reply with exactly "NO_REPLY"
- *    and nothing else.]
+ *   [In group chats, do not send a message back to the current group room
+ *    unless you are explicitly mentioned, addressed, or the room policy says
+ *    you should participate. This group-reply restriction only controls
+ *    whether you post back into the current group. It does not prevent
+ *    owner-approved or policy-approved background actions...]
  *
  * Owner-chat messages bypass the wrapper entirely — they are trusted and
  * the owner-chat scene prompt in `system-context.ts` already gives the

package/dist/turn-text.js

@@ -1,7 +1,15 @@
 import { sanitizeSenderName, sanitizeUntrustedContent } from "./gateway/index.js";
 import { classifyActivitySender } from "./sender-classify.js";
-const GROUP_HINT = '[In group chats, do NOT reply unless you are explicitly mentioned or addressed. ' +
-    'If no response is needed, reply with exactly "NO_REPLY" and nothing else.]';
+const GROUP_HINT = "[In group chats, do not send a message back to the current group room " +
+    "unless you are explicitly mentioned, addressed, or the room policy says you should participate.\n\n" +
+    "This group-reply restriction only controls whether you post back into the current group. " +
+    "It does not prevent you from performing owner-approved or policy-approved background actions, " +
+    "including analyzing the message, updating memory, calling tools, starting a task, " +
+    "forwarding a summary, or notifying the owner.\n\n" +
+    "When a message matches an active monitoring rule, automation goal, working-memory task, " +
+    "keyword, sender rule, or owner-approved workflow, perform the required action even if " +
+    "you do not reply to the group.\n\n" +
+    'If no group reply and no background action is needed, reply exactly "NO_REPLY".]';
 const DIRECT_HINT = '[If the conversation has naturally concluded or no response is needed, ' +
     'reply with exactly "NO_REPLY" and nothing else.]';
 /**

package/dist/working-memory.d.ts

@@ -10,10 +10,8 @@ export declare const MAX_GOAL_CHARS = 500;
 export declare const MAX_TOTAL_CHARS = 20000;
 export declare const DEFAULT_SECTION = "notes";
 /**
- * Canonical per-agent state directory. Returns the new location
- * (`~/.botcord/agents/{agentId}/state`). The legacy location under
- * `~/.botcord/daemon/memory/{agentId}` is migrated lazily on first read —
- * see §8 of the daemon-agent-workspace plan.
+ * Canonical per-agent memory directory. This intentionally matches
+ * @botcord/cli's `botcord memory` path so the CLI and daemon share one store.
  */
 export declare function resolveMemoryDir(agentId: string): string;
 export declare function readWorkingMemory(agentId: string): WorkingMemory | null;

package/dist/working-memory.js

@@ -1,13 +1,15 @@
 /**
  * Working memory — persistent, account-scoped notes injected into every turn.
  *
- * Stored at `~/.botcord/agents/{agentId}/state/working-memory.json` (the
- * per-agent state dir owned by the daemon).
+ * Stored at `~/.botcord/memory/{agentId}/working-memory.json`, matching the
+ * @botcord/cli `botcord memory` command so writes made by an agent are visible
+ * to daemon context injection on the next turn.
  *
  * Ported from plugin/src/memory.ts (dropping workspace + OpenClaw runtime
  * branches) and plugin/src/memory-protocol.ts (prompt builder).
  */
 import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
 import path from "node:path";
 import { agentStateDir } from "./agent-workspace.js";
 import { DAEMON_DIR_PATH } from "./config.js";
@@ -23,86 +25,94 @@ const MEMORY_SIZE_WARN_CHARS = 2_000;
 const RESERVED_TAGS_RE = /<\/?(?:current_memory|section_\w+)\b[^>]*>/gi;
 // ── Path resolution ────────────────────────────────────────────────
 /**
- * Canonical per-agent state directory. Returns the new location
- * (`~/.botcord/agents/{agentId}/state`). The legacy location under
- * `~/.botcord/daemon/memory/{agentId}` is migrated lazily on first read —
- * see §8 of the daemon-agent-workspace plan.
+ * Canonical per-agent memory directory. This intentionally matches
+ * @botcord/cli's `botcord memory` path so the CLI and daemon share one store.
  */
 export function resolveMemoryDir(agentId) {
     if (!agentId)
         throw new Error("resolveMemoryDir: agentId is required");
+    return path.join(homedir(), ".botcord", "memory", agentId);
+}
+/** Previous daemon-owned location retained for one-shot migration on read. */
+function daemonStateMemoryDir(agentId) {
     return agentStateDir(agentId);
 }
-/** Legacy location retained for one-shot migration on read. */
-function legacyMemoryDir(agentId) {
+/** Older daemon location retained for one-shot migration on read. */
+function daemonLegacyMemoryDir(agentId) {
     return path.join(DAEMON_DIR_PATH, "memory", agentId);
 }
 function workingMemoryPath(agentId) {
     return path.join(resolveMemoryDir(agentId), "working-memory.json");
 }
-function legacyWorkingMemoryPath(agentId) {
-    return path.join(legacyMemoryDir(agentId), "working-memory.json");
+function daemonStateWorkingMemoryPath(agentId) {
+    return path.join(daemonStateMemoryDir(agentId), "working-memory.json");
+}
+function daemonLegacyWorkingMemoryPath(agentId) {
+    return path.join(daemonLegacyMemoryDir(agentId), "working-memory.json");
 }
 // Migration conflict warnings are emitted at most once per agent per
 // process. Reset only by daemon restart — good enough for a one-release
 // transitional branch that gets removed later.
 const warnedMigrationConflict = new Set();
 /**
- * Resolve the path to read from, migrating from the legacy location if
+ * Resolve the path to read from, migrating from daemon-only locations if
  * necessary. Returns the path the caller should read, or `null` when no
  * memory file exists anywhere.
- *
- * Migration branch (the `else if` on `legacyExists` below) is meant to be
- * deleted one release after this change ships; see plan §8 step 6.
  */
 function resolveReadPath(agentId) {
-    const newPath = workingMemoryPath(agentId);
-    const oldPath = legacyWorkingMemoryPath(agentId);
-    const newExists = existsSync(newPath);
-    const oldExists = existsSync(oldPath);
-    if (newExists) {
-        if (oldExists && !warnedMigrationConflict.has(agentId)) {
+    const cliPath = workingMemoryPath(agentId);
+    const daemonStatePath = daemonStateWorkingMemoryPath(agentId);
+    const daemonLegacyPath = daemonLegacyWorkingMemoryPath(agentId);
+    const cliExists = existsSync(cliPath);
+    const daemonStateExists = existsSync(daemonStatePath);
+    const daemonLegacyExists = existsSync(daemonLegacyPath);
+    if (cliExists) {
+        if ((daemonStateExists || daemonLegacyExists) && !warnedMigrationConflict.has(agentId)) {
             warnedMigrationConflict.add(agentId);
-            daemonLog.warn("working-memory: both new and legacy paths exist; using new", {
+            daemonLog.warn("working-memory: both cli and daemon paths exist; using cli", {
                 agentId,
-                oldPath,
-                newPath,
+                cliPath,
+                daemonStatePath,
+                daemonLegacyPath,
             });
         }
-        return newPath;
+        return cliPath;
     }
-    if (oldExists) {
+    const migrateFrom = daemonStateExists
+        ? daemonStatePath
+        : daemonLegacyExists
+            ? daemonLegacyPath
+            : null;
+    if (migrateFrom) {
         try {
-            mkdirSync(path.dirname(newPath), { recursive: true, mode: 0o700 });
+            mkdirSync(path.dirname(cliPath), { recursive: true, mode: 0o700 });
             try {
-                renameSync(oldPath, newPath);
+                renameSync(migrateFrom, cliPath);
             }
             catch (err) {
-                // EXDEV = legacy and new paths live on different filesystems
+                // EXDEV = old and canonical paths live on different filesystems
                 // (bind mounts, tmpfs overlays). `renameSync` cannot cross fs
-                // boundaries, so fall back to copy + unlink. Without this, the
-                // next write would go to newPath while legacy still has the old
-                // payload — silent divergence the reviewer of §8 flagged.
+                // boundaries, so fall back to copy + unlink.
                 if (err.code === "EXDEV") {
-                    copyFileSync(oldPath, newPath);
-                    unlinkSync(oldPath);
+                    copyFileSync(migrateFrom, cliPath);
+                    unlinkSync(migrateFrom);
                 }
                 else {
                     throw err;
                 }
             }
-            return newPath;
+            return cliPath;
         }
         catch (err) {
             const e = err;
-            daemonLog.warn("working-memory: migration rename failed; reading legacy path", {
+            daemonLog.warn("working-memory: migration rename failed; reading daemon path", {
                 agentId,
-                oldPath,
-                newPath,
+                oldPath: migrateFrom,
+                newPath: cliPath,
                 code: e.code,
                 error: e.message ?? String(err),
             });
-            return oldPath;
+            return migrateFrom;
         }
     }
     return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.66",
+  "version": "0.2.68",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {
@@ -32,6 +32,9 @@
     "@larksuiteoapi/node-sdk": "^1.63.1",
     "ws": "^8.18.0"
   },
+  "overrides": {
+    "axios": "^1.15.2"
+  },
   "devDependencies": {
     "@types/node": "^20.0.0",
     "@types/ws": "^8.5.0",

package/src/__tests__/loop-risk.test.ts

@@ -22,7 +22,13 @@ describe("stripBotCordPromptScaffolding", () => {
       "hello world",
       "</agent-message>",
       "",
-      '[In group chats, do NOT reply unless you are explicitly mentioned or addressed. If no response is needed, reply with exactly "NO_REPLY" and nothing else.]',
+      "[In group chats, do not send a message back to the current group room unless you are explicitly mentioned, addressed, or the room policy says you should participate.",
+      "",
+      "This group-reply restriction only controls whether you post back into the current group. It does not prevent you from performing owner-approved or policy-approved background actions, including analyzing the message, updating memory, calling tools, starting a task, forwarding a summary, or notifying the owner.",
+      "",
+      "When a message matches an active monitoring rule, automation goal, working-memory task, keyword, sender rule, or owner-approved workflow, perform the required action even if you do not reply to the group.",
+      "",
+      'If no group reply and no background action is needed, reply exactly "NO_REPLY".]',
     ].join("\n");
     expect(stripBotCordPromptScaffolding(wrapped)).toBe("hello world");
   });

package/src/__tests__/path-env.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+import path from "node:path";
+import { commonDaemonPathEntries, mergePathEntries } from "../path-env.js";
+
+describe("path-env", () => {
+  it("adds common user CLI locations", () => {
+    expect(commonDaemonPathEntries("/Users/alice")).toEqual(
+      expect.arrayContaining([
+        "/Users/alice/.botcord/bin",
+        "/Users/alice/.local/bin",
+        "/Users/alice/.cargo/bin",
+        "/Users/alice/.bun/bin",
+        "/Users/alice/.pyenv/shims",
+      ]),
+    );
+  });
+
+  it("preserves existing PATH precedence and de-duplicates entries", () => {
+    const base = ["/usr/bin", "/bin", "/Users/alice/.local/bin"].join(path.delimiter);
+    const merged = mergePathEntries(base, [
+      "/Users/alice/.local/bin",
+      "/opt/homebrew/bin",
+      "/usr/bin",
+    ]);
+
+    expect(merged.split(path.delimiter)).toEqual([
+      "/usr/bin",
+      "/bin",
+      "/Users/alice/.local/bin",
+      "/opt/homebrew/bin",
+    ]);
+  });
+});

package/src/__tests__/turn-text.test.ts

@@ -34,7 +34,9 @@ describe("composeBotCordUserTurn", () => {
     expect(out).toContain('<agent-message sender="ag_alice" sender_kind="agent">');
     expect(out).toContain("hey everyone");
     expect(out).toContain("</agent-message>");
-    expect(out).toContain('do NOT reply unless you are explicitly mentioned');
+    expect(out).toContain("do not send a message back to the current group room");
+    expect(out).toContain("owner-approved or policy-approved background actions");
+    expect(out).toContain("active monitoring rule");
     expect(out).toContain('"NO_REPLY"');
   });
 
@@ -247,7 +249,8 @@ describe("composeBotCordUserTurn", () => {
     // Single-message header must NOT appear in batch mode.
     expect(out).not.toContain("[BotCord Message]");
     // Group hint still appears after the blocks.
-    expect(out).toContain("do NOT reply unless");
+    expect(out).toContain("do not send a message back to the current group room");
+    expect(out).toContain("no background action is needed");
   });
 
   it("batched path tags dashboard_human_room senders as human-message", () => {

package/src/__tests__/working-memory.test.ts

@@ -30,7 +30,11 @@ vi.mock("../log.js", () => ({
 const wm = await import("../working-memory.js");
 const { agentStateDir } = await import("../agent-workspace.js");
 
-function newPathFor(agentId: string): string {
+function cliPathFor(agentId: string): string {
+  return path.join(tmpHome, ".botcord", "memory", agentId, "working-memory.json");
+}
+
+function daemonStatePathFor(agentId: string): string {
   return path.join(agentStateDir(agentId), "working-memory.json");
 }
 
@@ -44,8 +48,14 @@ function writeLegacy(agentId: string, body: unknown): void {
   writeFileSync(p, JSON.stringify(body));
 }
 
-function writeNew(agentId: string, body: unknown): void {
-  const p = newPathFor(agentId);
+function writeDaemonState(agentId: string, body: unknown): void {
+  const p = daemonStatePathFor(agentId);
+  mkdirSync(path.dirname(p), { recursive: true });
+  writeFileSync(p, JSON.stringify(body));
+}
+
+function writeCli(agentId: string, body: unknown): void {
+  const p = cliPathFor(agentId);
   mkdirSync(path.dirname(p), { recursive: true });
   writeFileSync(p, JSON.stringify(body));
 }
@@ -79,9 +89,10 @@ describe("working-memory I/O", () => {
     expect(got?.updatedAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
   });
 
-  it("writes land in the new state dir", () => {
+  it("writes land in the CLI-compatible memory dir", () => {
     wm.updateWorkingMemory("ag_new", { goal: "g" });
-    expect(existsSync(newPathFor("ag_new"))).toBe(true);
+    expect(existsSync(cliPathFor("ag_new"))).toBe(true);
+    expect(existsSync(daemonStatePathFor("ag_new"))).toBe(false);
     expect(existsSync(legacyPathFor("ag_new"))).toBe(false);
   });
 
@@ -136,34 +147,51 @@ describe("working-memory I/O", () => {
   });
 });
 
-describe("working-memory migration (§8)", () => {
-  it("reads from new path when present and ignores legacy", () => {
-    writeNew("ag_mig", { version: 2, sections: { notes: "fresh" }, updatedAt: "2026-01-01" });
+describe("working-memory migration", () => {
+  it("reads from CLI path when present and ignores daemon paths", () => {
+    writeCli("ag_mig", { version: 2, sections: { notes: "fresh" }, updatedAt: "2026-01-01" });
+    writeDaemonState("ag_mig", { version: 2, sections: { notes: "state" }, updatedAt: "2025-01-01" });
     writeLegacy("ag_mig", { version: 2, sections: { notes: "stale" }, updatedAt: "2024-01-01" });
 
     const got = wm.readWorkingMemory("ag_mig");
     expect(got?.sections.notes).toBe("fresh");
-    // Legacy is left in place when new wins; warning is emitted once.
+    // Old daemon paths are left in place when CLI wins; warning is emitted once.
+    expect(existsSync(daemonStatePathFor("ag_mig"))).toBe(true);
     expect(existsSync(legacyPathFor("ag_mig"))).toBe(true);
     expect(warnSpy).toHaveBeenCalled();
   });
 
-  it("renames legacy → new on first read when only legacy exists", () => {
+  it("renames daemon state → CLI path on first read when only daemon state exists", () => {
+    writeDaemonState("ag_onlystate", {
+      version: 2,
+      sections: { notes: "state notes" },
+      updatedAt: "2025-01-01",
+    });
+    expect(existsSync(cliPathFor("ag_onlystate"))).toBe(false);
+
+    const got = wm.readWorkingMemory("ag_onlystate");
+    expect(got?.sections.notes).toBe("state notes");
+
+    expect(existsSync(daemonStatePathFor("ag_onlystate"))).toBe(false);
+    expect(existsSync(cliPathFor("ag_onlystate"))).toBe(true);
+  });
+
+  it("renames legacy daemon memory → CLI path on first read when only legacy exists", () => {
     writeLegacy("ag_onlyold", {
       version: 2,
       sections: { notes: "old notes" },
       updatedAt: "2024-01-01",
     });
-    expect(existsSync(newPathFor("ag_onlyold"))).toBe(false);
+    expect(existsSync(cliPathFor("ag_onlyold"))).toBe(false);
 
     const got = wm.readWorkingMemory("ag_onlyold");
     expect(got?.sections.notes).toBe("old notes");
 
-    // Legacy moved away; new path now holds the data.
+    // Legacy moved away; CLI path now holds the data.
     expect(existsSync(legacyPathFor("ag_onlyold"))).toBe(false);
-    expect(existsSync(newPathFor("ag_onlyold"))).toBe(true);
+    expect(existsSync(cliPathFor("ag_onlyold"))).toBe(true);
 
-    // Subsequent reads come from new path — delete legacy dir tree to
+    // Subsequent reads come from CLI path — delete legacy dir tree to
     // prove no re-read falls through to it.
     const got2 = wm.readWorkingMemory("ag_onlyold");
     expect(got2?.sections.notes).toBe("old notes");
@@ -180,13 +208,13 @@ describe("working-memory migration (§8)", () => {
       updatedAt: "2024-01-01",
     });
 
-    // Plant a regular file where the new state *directory* would live, so
+    // Plant a regular file where the CLI memory *directory* would live, so
     // mkdirSync+renameSync inside the migration branch fails with ENOTDIR
-    // (the agent home's `state` path already exists as a file). The
+    // (`~/.botcord/memory/<agentId>` already exists as a file). The
     // migration path must log and fall back to reading the legacy file.
-    const home = path.join(tmpHome, ".botcord", "agents", "ag_renamefail");
+    const home = path.join(tmpHome, ".botcord", "memory");
     mkdirSync(home, { recursive: true });
-    writeFileSync(path.join(home, "state"), "not a dir");
+    writeFileSync(path.join(home, "ag_renamefail"), "not a dir");
 
     const got = wm.readWorkingMemory("ag_renamefail");
     expect(got?.sections.notes).toBe("still readable");

package/src/index.ts

@@ -3,6 +3,7 @@ import { spawn } from "node:child_process";
 import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync, statSync, rmSync } from "node:fs";
 import { homedir, hostname } from "node:os";
 import path from "node:path";
+import { augmentProcessPath } from "./path-env.js";
 import {
   loadConfig,
   saveConfig,
@@ -65,6 +66,8 @@ import {
   openclawDiscoveryConfigEnabled,
 } from "./openclaw-discovery.js";
 
+augmentProcessPath();
+
 const ADAPTER_LIST = listAdapterIds().join("|");
 
 const DEFAULT_HUB = "https://api.botcord.chat";

package/src/loop-risk.ts

@@ -83,9 +83,16 @@ export function stripBotCordPromptScaffolding(text: string): string {
       if (line.startsWith("[BotCord Message]")) return false;
       if (line.startsWith("[BotCord Notification]")) return false;
       if (line.startsWith("[Room Rule]")) return false;
-      if (line.startsWith("[In group chats, do NOT reply")) return false;
+      if (line.startsWith("[In group chats,")) return false;
+      if (line.startsWith("This group-reply restriction")) return false;
+      if (line.startsWith("including analyzing the message")) return false;
+      if (line.startsWith("forwarding a summary")) return false;
+      if (line.startsWith("When a message matches an active monitoring rule")) return false;
+      if (line.startsWith("keyword, sender rule")) return false;
+      if (line.startsWith("you do not reply to the group")) return false;
       if (line.startsWith("[If the conversation has naturally concluded")) return false;
       if (line.startsWith("[You received a contact request")) return false;
+      if (line.includes("no background action is needed")) return false;
       if (line.includes('reply with exactly "NO_REPLY"')) return false;
       if (line.startsWith("<agent-message")) return false;
       if (line === "</agent-message>") return false;

package/src/path-env.ts

@@ -0,0 +1,53 @@
+import path from "node:path";
+
+const COMMON_USER_BIN_RELATIVE_PATHS = [
+  ".botcord/bin",
+  ".local/bin",
+  ".cargo/bin",
+  ".bun/bin",
+  ".deno/bin",
+  ".npm-global/bin",
+  ".yarn/bin",
+  ".pnpm",
+  ".pyenv/shims",
+  ".rye/shims",
+  ".pixi/bin",
+];
+
+const COMMON_SYSTEM_BIN_PATHS =
+  process.platform === "darwin"
+    ? ["/opt/homebrew/bin", "/opt/homebrew/sbin", "/usr/local/bin", "/usr/local/sbin"]
+    : ["/usr/local/bin", "/usr/local/sbin"];
+
+export function commonDaemonPathEntries(home = process.env.HOME): string[] {
+  const userEntries = home
+    ? COMMON_USER_BIN_RELATIVE_PATHS.map((entry) => path.join(home, entry))
+    : [];
+  return [...COMMON_SYSTEM_BIN_PATHS, ...userEntries];
+}
+
+export function mergePathEntries(basePath: string | undefined, extras: string[]): string {
+  const seen = new Set<string>();
+  const out: string[] = [];
+
+  for (const raw of [...(basePath ?? "").split(path.delimiter), ...extras]) {
+    const entry = raw.trim();
+    if (!entry || seen.has(entry)) continue;
+    seen.add(entry);
+    out.push(entry);
+  }
+
+  return out.join(path.delimiter);
+}
+
+/**
+ * GUI-launched macOS apps inherit a sparse launchd PATH and do not read the
+ * user's shell profile. Add common per-user CLI install locations so runtime
+ * adapters can find tools installed by uv/pipx, cargo, bun, npm, etc.
+ */
+export function augmentProcessPath(): void {
+  process.env.PATH = mergePathEntries(
+    process.env.PATH,
+    commonDaemonPathEntries(process.env.HOME),
+  );
+}

package/src/turn-text.ts

@@ -15,9 +15,11 @@
  *   hello
  *   </agent-message>
  *
- *   [In group chats, do NOT reply unless you are explicitly mentioned or
- *    addressed. If no response is needed, reply with exactly "NO_REPLY"
- *    and nothing else.]
+ *   [In group chats, do not send a message back to the current group room
+ *    unless you are explicitly mentioned, addressed, or the room policy says
+ *    you should participate. This group-reply restriction only controls
+ *    whether you post back into the current group. It does not prevent
+ *    owner-approved or policy-approved background actions...]
  *
  * Owner-chat messages bypass the wrapper entirely — they are trusted and
  * the owner-chat scene prompt in `system-context.ts` already gives the
@@ -28,8 +30,16 @@ import { sanitizeSenderName, sanitizeUntrustedContent } from "./gateway/index.js
 import { classifyActivitySender } from "./sender-classify.js";
 
 const GROUP_HINT =
-  '[In group chats, do NOT reply unless you are explicitly mentioned or addressed. ' +
-  'If no response is needed, reply with exactly "NO_REPLY" and nothing else.]';
+  "[In group chats, do not send a message back to the current group room " +
+  "unless you are explicitly mentioned, addressed, or the room policy says you should participate.\n\n" +
+  "This group-reply restriction only controls whether you post back into the current group. " +
+  "It does not prevent you from performing owner-approved or policy-approved background actions, " +
+  "including analyzing the message, updating memory, calling tools, starting a task, " +
+  "forwarding a summary, or notifying the owner.\n\n" +
+  "When a message matches an active monitoring rule, automation goal, working-memory task, " +
+  "keyword, sender rule, or owner-approved workflow, perform the required action even if " +
+  "you do not reply to the group.\n\n" +
+  'If no group reply and no background action is needed, reply exactly "NO_REPLY".]';
 const DIRECT_HINT =
   '[If the conversation has naturally concluded or no response is needed, ' +
   'reply with exactly "NO_REPLY" and nothing else.]';

package/src/working-memory.ts

@@ -1,8 +1,9 @@
 /**
  * Working memory — persistent, account-scoped notes injected into every turn.
  *
- * Stored at `~/.botcord/agents/{agentId}/state/working-memory.json` (the
- * per-agent state dir owned by the daemon).
+ * Stored at `~/.botcord/memory/{agentId}/working-memory.json`, matching the
+ * @botcord/cli `botcord memory` command so writes made by an agent are visible
+ * to daemon context injection on the next turn.
  *
  * Ported from plugin/src/memory.ts (dropping workspace + OpenClaw runtime
  * branches) and plugin/src/memory-protocol.ts (prompt builder).
@@ -16,6 +17,7 @@ import {
   unlinkSync,
   writeFileSync,
 } from "node:fs";
+import { homedir } from "node:os";
 import path from "node:path";
 import { agentStateDir } from "./agent-workspace.js";
 import { DAEMON_DIR_PATH } from "./config.js";
@@ -50,18 +52,21 @@ const RESERVED_TAGS_RE = /<\/?(?:current_memory|section_\w+)\b[^>]*>/gi;
 // ── Path resolution ────────────────────────────────────────────────
 
 /**
- * Canonical per-agent state directory. Returns the new location
- * (`~/.botcord/agents/{agentId}/state`). The legacy location under
- * `~/.botcord/daemon/memory/{agentId}` is migrated lazily on first read —
- * see §8 of the daemon-agent-workspace plan.
+ * Canonical per-agent memory directory. This intentionally matches
+ * @botcord/cli's `botcord memory` path so the CLI and daemon share one store.
  */
 export function resolveMemoryDir(agentId: string): string {
   if (!agentId) throw new Error("resolveMemoryDir: agentId is required");
+  return path.join(homedir(), ".botcord", "memory", agentId);
+}
+
+/** Previous daemon-owned location retained for one-shot migration on read. */
+function daemonStateMemoryDir(agentId: string): string {
   return agentStateDir(agentId);
 }
 
-/** Legacy location retained for one-shot migration on read. */
-function legacyMemoryDir(agentId: string): string {
+/** Older daemon location retained for one-shot migration on read. */
+function daemonLegacyMemoryDir(agentId: string): string {
   return path.join(DAEMON_DIR_PATH, "memory", agentId);
 }
 
@@ -69,8 +74,12 @@ function workingMemoryPath(agentId: string): string {
   return path.join(resolveMemoryDir(agentId), "working-memory.json");
 }
 
-function legacyWorkingMemoryPath(agentId: string): string {
-  return path.join(legacyMemoryDir(agentId), "working-memory.json");
+function daemonStateWorkingMemoryPath(agentId: string): string {
+  return path.join(daemonStateMemoryDir(agentId), "working-memory.json");
+}
+
+function daemonLegacyWorkingMemoryPath(agentId: string): string {
+  return path.join(daemonLegacyMemoryDir(agentId), "working-memory.json");
 }
 
 // Migration conflict warnings are emitted at most once per agent per
@@ -79,59 +88,63 @@ function legacyWorkingMemoryPath(agentId: string): string {
 const warnedMigrationConflict = new Set<string>();
 
 /**
- * Resolve the path to read from, migrating from the legacy location if
+ * Resolve the path to read from, migrating from daemon-only locations if
  * necessary. Returns the path the caller should read, or `null` when no
  * memory file exists anywhere.
- *
- * Migration branch (the `else if` on `legacyExists` below) is meant to be
- * deleted one release after this change ships; see plan §8 step 6.
  */
 function resolveReadPath(agentId: string): string | null {
-  const newPath = workingMemoryPath(agentId);
-  const oldPath = legacyWorkingMemoryPath(agentId);
-  const newExists = existsSync(newPath);
-  const oldExists = existsSync(oldPath);
-
-  if (newExists) {
-    if (oldExists && !warnedMigrationConflict.has(agentId)) {
+  const cliPath = workingMemoryPath(agentId);
+  const daemonStatePath = daemonStateWorkingMemoryPath(agentId);
+  const daemonLegacyPath = daemonLegacyWorkingMemoryPath(agentId);
+  const cliExists = existsSync(cliPath);
+  const daemonStateExists = existsSync(daemonStatePath);
+  const daemonLegacyExists = existsSync(daemonLegacyPath);
+
+  if (cliExists) {
+    if ((daemonStateExists || daemonLegacyExists) && !warnedMigrationConflict.has(agentId)) {
       warnedMigrationConflict.add(agentId);
-      daemonLog.warn("working-memory: both new and legacy paths exist; using new", {
+      daemonLog.warn("working-memory: both cli and daemon paths exist; using cli", {
         agentId,
-        oldPath,
-        newPath,
+        cliPath,
+        daemonStatePath,
+        daemonLegacyPath,
       });
     }
-    return newPath;
+    return cliPath;
   }
-  if (oldExists) {
+
+  const migrateFrom = daemonStateExists
+    ? daemonStatePath
+    : daemonLegacyExists
+      ? daemonLegacyPath
+      : null;
+  if (migrateFrom) {
     try {
-      mkdirSync(path.dirname(newPath), { recursive: true, mode: 0o700 });
+      mkdirSync(path.dirname(cliPath), { recursive: true, mode: 0o700 });
       try {
-        renameSync(oldPath, newPath);
+        renameSync(migrateFrom, cliPath);
       } catch (err) {
-        // EXDEV = legacy and new paths live on different filesystems
+        // EXDEV = old and canonical paths live on different filesystems
         // (bind mounts, tmpfs overlays). `renameSync` cannot cross fs
-        // boundaries, so fall back to copy + unlink. Without this, the
-        // next write would go to newPath while legacy still has the old
-        // payload — silent divergence the reviewer of §8 flagged.
+        // boundaries, so fall back to copy + unlink.
         if ((err as NodeJS.ErrnoException).code === "EXDEV") {
-          copyFileSync(oldPath, newPath);
-          unlinkSync(oldPath);
+          copyFileSync(migrateFrom, cliPath);
+          unlinkSync(migrateFrom);
         } else {
           throw err;
         }
       }
-      return newPath;
+      return cliPath;
     } catch (err) {
       const e = err as NodeJS.ErrnoException;
-      daemonLog.warn("working-memory: migration rename failed; reading legacy path", {
+      daemonLog.warn("working-memory: migration rename failed; reading daemon path", {
         agentId,
-        oldPath,
-        newPath,
+        oldPath: migrateFrom,
+        newPath: cliPath,
         code: e.code,
         error: e.message ?? String(err),
       });
-      return oldPath;
+      return migrateFrom;
     }
   }
   return null;