@botcord/daemon 0.2.68 → 0.2.70

package/dist/agent-workspace.js

@@ -20,6 +20,7 @@ import { chmodSync, copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, read
 import { createRequire } from "node:module";
 import { homedir } from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 const require = createRequire(import.meta.url);
 // Accepted agent id pattern. Enforced at every path-builder entry so a
 // malicious / malformed agentId (e.g. "../../etc") cannot escape
@@ -357,8 +358,24 @@ export function ensureAgentHermesWorkspace(agentId, opts = {}) {
  * Seeded fresh per `ensureAgent*` call (force-overwrite) so daemon
  * upgrades propagate.
  */
-const BUNDLED_SKILLS = ["botcord", "botcord-user-guide"];
+const BUNDLED_SKILLS = ["botcord", "botcord-user-guide", "botcord_memory"];
+function resolveRepoCliSkillsRoot() {
+    let dir = path.dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 6; i += 1) {
+        const candidate = path.join(dir, "cli", "skills");
+        if (existsSync(candidate))
+            return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
 function resolveBundledCliSkillsRoot() {
+    const repoRoot = resolveRepoCliSkillsRoot();
+    if (repoRoot)
+        return repoRoot;
     try {
         const pkgJsonPath = require.resolve("@botcord/cli/package.json");
         const root = path.join(path.dirname(pkgJsonPath), "skills");

package/dist/gateway/gateway.d.ts

@@ -2,7 +2,7 @@ import { type ChannelBackoffOptions } from "./channel-manager.js";
 import { type RuntimeFactory } from "./dispatcher.js";
 import { type GatewayLogger } from "./log.js";
 import { type TranscriptWriter } from "./transcript.js";
-import type { ChannelAdapter, GatewayChannelConfig, GatewayConfig, GatewayInboundMessage, GatewayRoute, GatewayRuntimeSnapshot, InboundObserver, OutboundObserver, SystemContextBuilder, UserTurnBuilder } from "./types.js";
+import type { ChannelAdapter, GatewayChannelConfig, GatewayConfig, GatewayInboundMessage, GatewayOutboundMessage, GatewayRoute, GatewayRuntimeSnapshot, InboundObserver, OutboundObserver, SystemContextBuilder, UserTurnBuilder } from "./types.js";
 /** Constructor options for `Gateway`. */
 export interface GatewayBootOptions {
     config: GatewayConfig;
@@ -124,4 +124,12 @@ export declare class Gateway {
      * routing, queueing, transcript, and runtime behavior as channel messages.
      */
     injectInbound(message: GatewayInboundMessage): Promise<void>;
+    /**
+     * Send a daemon-control initiated outbound message through a registered
+     * channel. Used by proactive third-party gateway sends where the runtime
+     * explicitly targets an external provider conversation.
+     */
+    sendOutbound(message: GatewayOutboundMessage): Promise<{
+        providerMessageId?: string | null;
+    }>;
 }

package/dist/gateway/gateway.js

@@ -174,4 +174,16 @@ export class Gateway {
     async injectInbound(message) {
         await this.dispatcher.handle({ message });
     }
+    /**
+     * Send a daemon-control initiated outbound message through a registered
+     * channel. Used by proactive third-party gateway sends where the runtime
+     * explicitly targets an external provider conversation.
+     */
+    async sendOutbound(message) {
+        const channel = this.channelMap.get(message.channel);
+        if (!channel) {
+            throw new Error(`channel "${message.channel}" is not registered`);
+        }
+        return channel.send({ message, log: this.log });
+    }
 }

package/dist/gateway-control.d.ts

@@ -60,6 +60,13 @@ interface GatewayRecentSendersParams {
     accountId: string;
     timeoutSeconds?: number;
 }
+interface GatewaySendParams {
+    agentId: string;
+    gatewayId: string;
+    conversationId: string;
+    text: string;
+    idempotencyKey?: string;
+}
 export type { FetchLike };
 export interface GatewayControlContext {
     gateway: Gateway;
@@ -98,6 +105,7 @@ export declare function createGatewayControl(ctx: GatewayControlContext): {
     handleLoginStart: (params: GatewayLoginStartParams) => Promise<AckBody>;
     handleLoginStatus: (params: GatewayLoginStatusParams) => Promise<AckBody>;
     handleRecentSenders: (params: GatewayRecentSendersParams) => Promise<AckBody>;
+    handleSend: (params: GatewaySendParams) => Promise<AckBody>;
     /** Exposed for tests — direct access to the in-memory session map. */
     _sessions: LoginSessionStore;
 };

package/dist/gateway-control.js

@@ -731,6 +731,78 @@ export function createGatewayControl(ctx) {
             };
         }
     }
+    // --- gateway_send -------------------------------------------------------
+    async function handleSend(params) {
+        if (!params.agentId || typeof params.agentId !== "string") {
+            return badParams("gateway_send: agentId is required");
+        }
+        if (!params.gatewayId || typeof params.gatewayId !== "string") {
+            return badParams("gateway_send: gatewayId is required");
+        }
+        if (!params.conversationId || typeof params.conversationId !== "string") {
+            return badParams("gateway_send: conversationId is required");
+        }
+        if (typeof params.text !== "string" || params.text.length === 0) {
+            return badParams("gateway_send: text is required");
+        }
+        const cfg = cfgIO.load();
+        const profile = (cfg.thirdPartyGateways ?? []).find((g) => g.id === params.gatewayId);
+        if (!profile) {
+            return {
+                ok: false,
+                error: { code: "unknown_gateway", message: `no gateway with id "${params.gatewayId}"` },
+            };
+        }
+        if (profile.accountId !== params.agentId) {
+            return {
+                ok: false,
+                error: { code: "account_mismatch", message: "gateway is bound to a different agent" },
+            };
+        }
+        if (profile.enabled === false) {
+            return {
+                ok: false,
+                error: { code: "gateway_disabled", message: "gateway is disabled" },
+            };
+        }
+        if (profile.type === "wechat") {
+            return {
+                ok: false,
+                error: { code: "unsupported_provider", message: "wechat gateway_send requires an inbound context_token and is not supported" },
+            };
+        }
+        const conversationErr = validateOutboundConversation(profile, params.conversationId);
+        if (conversationErr)
+            return conversationErr;
+        try {
+            const sendResult = await ctx.gateway.sendOutbound({
+                channel: params.gatewayId,
+                accountId: params.agentId,
+                conversationId: params.conversationId,
+                text: params.text,
+                traceId: `gateway-send:${params.idempotencyKey ?? Date.now()}`,
+            });
+            const result = {
+                gatewayId: params.gatewayId,
+                conversationId: params.conversationId,
+                providerMessageId: sendResult.providerMessageId ?? null,
+            };
+            return { ok: true, result };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            daemonLog.warn("gateway_send failed", {
+                gatewayId: params.gatewayId,
+                accountId: params.agentId,
+                conversationId: params.conversationId,
+                error: message,
+            });
+            return {
+                ok: false,
+                error: { code: "send_failed", message },
+            };
+        }
+    }
     return {
         handleList,
         handleUpsert,
@@ -739,6 +811,7 @@ export function createGatewayControl(ctx) {
         handleLoginStart,
         handleLoginStatus,
         handleRecentSenders,
+        handleSend,
         /** Exposed for tests — direct access to the in-memory session map. */
         _sessions: sessions,
     };
@@ -761,6 +834,50 @@ function validateUpsertParams(p) {
         return "upsert_gateway: accountId is required";
     return null;
 }
+function validateOutboundConversation(profile, conversationId) {
+    const chatId = chatIdFromConversation(profile.type, conversationId);
+    if (!chatId) {
+        return {
+            ok: false,
+            error: {
+                code: "bad_conversation",
+                message: `conversationId "${conversationId}" is not valid for ${profile.type}`,
+            },
+        };
+    }
+    const allowed = new Set((profile.allowedChatIds ?? []).map(String));
+    if (!allowed.has(chatId)) {
+        return {
+            ok: false,
+            error: {
+                code: "conversation_not_allowed",
+                message: "conversation is not in the gateway allowedChatIds list",
+            },
+        };
+    }
+    return null;
+}
+function chatIdFromConversation(provider, conversationId) {
+    if (provider === "telegram") {
+        if (conversationId.startsWith("telegram:user:")) {
+            return conversationId.slice("telegram:user:".length);
+        }
+        if (conversationId.startsWith("telegram:group:")) {
+            return conversationId.slice("telegram:group:".length);
+        }
+        return null;
+    }
+    if (provider === "feishu") {
+        if (conversationId.startsWith("feishu:user:")) {
+            return conversationId.slice("feishu:user:".length);
+        }
+        if (conversationId.startsWith("feishu:chat:")) {
+            return conversationId.slice("feishu:chat:".length);
+        }
+        return null;
+    }
+    return null;
+}
 function annotateProfile(p, status) {
     return {
         id: p.id,

package/dist/loop-risk.js

@@ -76,6 +76,12 @@ export function stripBotCordPromptScaffolding(text) {
             return false;
         if (line.startsWith("you do not reply to the group"))
             return false;
+        if (line.startsWith("Before replying NO_REPLY in a non-owner group room"))
+            return false;
+        if (line.startsWith("match a memory-backed monitoring rule"))
+            return false;
+        if (line.startsWith("or owner-approved workflow. If needed"))
+            return false;
         if (line.startsWith("[If the conversation has naturally concluded"))
             return false;
         if (line.startsWith("[You received a contact request"))

package/dist/provision.js

@@ -255,6 +255,14 @@ export function createProvisioner(opts) {
                     return v.ack;
                 return gatewayControl.handleRecentSenders(v.params);
             }
+            case "gateway_send": {
+                const v = validateGatewayParams(frame.params, {
+                    required: ["agentId", "gatewayId", "conversationId", "text"],
+                });
+                if (!v.ok)
+                    return v.ack;
+                return gatewayControl.handleSend(v.params);
+            }
             case "list_agent_files": {
                 const params = (frame.params ?? {});
                 if (!params.agentId) {
@@ -344,6 +352,8 @@ async function handleWakeAgent(gateway, raw) {
     }
     const runId = params.run_id || params.runId || `wake-${Date.now()}`;
     const scheduleId = params.schedule_id || params.scheduleId;
+    const scheduledFor = params.scheduled_for || params.scheduledFor;
+    const dispatchedAt = params.dispatched_at || params.dispatchedAt;
     const dedupeKey = params.dedupe_key || params.dedupeKey;
     const conversationId = `rm_schedule_${agentId}`;
     const msg = {
@@ -365,6 +375,8 @@ async function handleWakeAgent(gateway, raw) {
         raw: {
             source_type: "botcord_schedule",
             schedule_id: scheduleId,
+            scheduled_for: scheduledFor,
+            dispatched_at: dispatchedAt,
             run_id: runId,
             dedupe_key: dedupeKey,
         },

package/dist/turn-text.js

@@ -9,6 +9,10 @@ const GROUP_HINT = "[In group chats, do not send a message back to the current g
     "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" +
+    "Before replying NO_REPLY in a non-owner group room, consider whether this message could " +
+    "match a memory-backed monitoring rule, automation goal, pending task, keyword, sender rule, " +
+    "or owner-approved workflow. If needed, use the botcord_memory skill to retrieve or update " +
+    "working memory.\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.]';
@@ -56,6 +60,31 @@ function appendConversationFields(fields, msg) {
         fields.push(`channel: ${sanitizeSenderName(msg.channel)}`);
     }
 }
+function formatScheduleContext(raw) {
+    const r = raw && typeof raw === "object" ? raw : {};
+    if (r.source_type !== "botcord_schedule")
+        return [];
+    const fields = [];
+    if (typeof r.schedule_id === "string" && r.schedule_id) {
+        fields.push(`schedule_id: ${sanitizeSenderName(r.schedule_id)}`);
+    }
+    if (typeof r.scheduled_for === "string" && r.scheduled_for) {
+        fields.push(`scheduled_for: ${sanitizeSenderName(r.scheduled_for)}`);
+    }
+    if (typeof r.dispatched_at === "string" && r.dispatched_at) {
+        fields.push(`dispatched_at: ${sanitizeSenderName(r.dispatched_at)}`);
+    }
+    if (typeof r.run_id === "string" && r.run_id) {
+        fields.push(`run_id: ${sanitizeSenderName(r.run_id)}`);
+    }
+    return fields.length > 0
+        ? [
+            "[BotCord Schedule]",
+            "This turn was triggered by a proactive schedule.",
+            fields.join(" | "),
+        ]
+        : ["[BotCord Schedule]", "This turn was triggered by a proactive schedule."];
+}
 /**
  * Read the `raw.batch` array emitted by the BotCord channel when inbox
  * drain groups multiple messages for the same `(room, topic)`. Returns the
@@ -179,6 +208,7 @@ export function composeBotCordUserTurn(msg) {
         : null;
     const lines = [
         headerFields.join(" | "),
+        ...formatScheduleContext(msg.raw),
         ...(isGroup ? formatRoomContext(msg.raw, { id: conversation.id, title: roomTitle }) : []),
         `<${tag} sender="${sanitizedSenderLabel}" sender_kind="${senderKindAttr}">`,
         trimmed,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.68",
+  "version": "0.2.70",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {
@@ -30,7 +30,7 @@
     "@botcord/cli": "^0.1.7",
     "@botcord/protocol-core": "^0.2.4",
     "@larksuiteoapi/node-sdk": "^1.63.1",
-    "ws": "^8.18.0"
+    "ws": "^8.20.1"
   },
   "overrides": {
     "axios": "^1.15.2"

package/src/__tests__/agent-workspace.test.ts

@@ -88,6 +88,7 @@ describe("ensureAgentWorkspace", () => {
     const skillsDir = path.join(agentWorkspaceDir("ag_skills"), ".claude", "skills");
     expect(existsSync(path.join(skillsDir, "botcord", "SKILL.md"))).toBe(true);
     expect(existsSync(path.join(skillsDir, "botcord-user-guide", "SKILL.md"))).toBe(true);
+    expect(existsSync(path.join(skillsDir, "botcord_memory", "SKILL.md"))).toBe(true);
   });
 
   it("re-seeds skills on a second call so daemon upgrades propagate", () => {
@@ -113,6 +114,7 @@ describe("ensureAgentWorkspace", () => {
     const skillsDir = path.join(agentCodexHomeDir("ag_codex_skills"), "skills");
     expect(existsSync(path.join(skillsDir, "botcord", "SKILL.md"))).toBe(true);
     expect(existsSync(path.join(skillsDir, "botcord-user-guide", "SKILL.md"))).toBe(true);
+    expect(existsSync(path.join(skillsDir, "botcord_memory", "SKILL.md"))).toBe(true);
   });
 
   it("re-seeds codex skills on subsequent ensureAgentCodexHome calls", () => {
@@ -137,6 +139,7 @@ describe("ensureAgentWorkspace", () => {
     const skillsDir = path.join(hermesHome, "skills");
     expect(existsSync(path.join(skillsDir, "botcord", "SKILL.md"))).toBe(true);
     expect(existsSync(path.join(skillsDir, "botcord-user-guide", "SKILL.md"))).toBe(true);
+    expect(existsSync(path.join(skillsDir, "botcord_memory", "SKILL.md"))).toBe(true);
   });
 
   it("re-seeds hermes skills on subsequent ensureAgentHermesWorkspace calls", () => {
@@ -164,6 +167,9 @@ describe("ensureAgentWorkspace", () => {
     expect(existsSync(path.join(profileHome, "skills", "botcord-user-guide", "SKILL.md"))).toBe(
       true,
     );
+    expect(existsSync(path.join(profileHome, "skills", "botcord_memory", "SKILL.md"))).toBe(
+      true,
+    );
     expect(existsSync(hermesWorkspace)).toBe(true);
     expect(existsSync(hermesHome)).toBe(false);
   });

package/src/__tests__/gateway-control.test.ts

@@ -43,6 +43,7 @@ interface FakeGateway {
   channels: Map<string, { id: string; status: Record<string, unknown> }>;
   addChannel: ReturnType<typeof vi.fn>;
   removeChannel: ReturnType<typeof vi.fn>;
+  sendOutbound: ReturnType<typeof vi.fn>;
   snapshot: () => { channels: Record<string, any>; turns: Record<string, any> };
 }
 
@@ -66,6 +67,7 @@ function makeFakeGateway(): FakeGateway {
     removeChannel: vi.fn(async (id: string) => {
       channels.delete(id);
     }),
+    sendOutbound: vi.fn(async () => ({ providerMessageId: "provider-msg-1" })),
     snapshot: () => ({
       channels: Object.fromEntries([...channels].map(([id, e]) => [id, e.status])),
       turns: {},
@@ -617,6 +619,75 @@ describe("list_gateways", () => {
   });
 });
 
+describe("gateway_send", () => {
+  it("sends through an enabled allowed telegram gateway", async () => {
+    const gw = makeFakeGateway();
+    const gwId = uniqId("send");
+    const { io } = makeConfigIO({
+      ...baseCfg(),
+      thirdPartyGateways: [
+        {
+          id: gwId,
+          type: "telegram",
+          accountId: "ag_alice",
+          enabled: true,
+          allowedChatIds: ["-1001"],
+        },
+      ],
+    });
+    const ctrl = createGatewayControl({ gateway: gw as any, configIO: io });
+
+    const ack = await ctrl.handleSend({
+      agentId: "ag_alice",
+      gatewayId: gwId,
+      conversationId: "telegram:group:-1001",
+      text: "hello",
+      idempotencyKey: "k1",
+    });
+
+    expect(ack.ok).toBe(true);
+    expect(gw.sendOutbound).toHaveBeenCalledWith(
+      expect.objectContaining({
+        channel: gwId,
+        accountId: "ag_alice",
+        conversationId: "telegram:group:-1001",
+        text: "hello",
+        traceId: "gateway-send:k1",
+      }),
+    );
+    expect((ack.result as any).providerMessageId).toBe("provider-msg-1");
+  });
+
+  it("rejects conversations outside allowedChatIds", async () => {
+    const gw = makeFakeGateway();
+    const gwId = uniqId("send-deny");
+    const { io } = makeConfigIO({
+      ...baseCfg(),
+      thirdPartyGateways: [
+        {
+          id: gwId,
+          type: "feishu",
+          accountId: "ag_alice",
+          enabled: true,
+          allowedChatIds: ["oc_allowed"],
+        },
+      ],
+    });
+    const ctrl = createGatewayControl({ gateway: gw as any, configIO: io });
+
+    const ack = await ctrl.handleSend({
+      agentId: "ag_alice",
+      gatewayId: gwId,
+      conversationId: "feishu:chat:oc_other",
+      text: "hello",
+    });
+
+    expect(ack.ok).toBe(false);
+    expect(ack.error?.code).toBe("conversation_not_allowed");
+    expect(gw.sendOutbound).not.toHaveBeenCalled();
+  });
+});
+
 describe("W4: handleLoginStatus accountId ownership check", () => {
   it("returns forbidden when accountId does not match the login session", async () => {
     const gw = makeFakeGateway();

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

@@ -28,6 +28,8 @@ describe("stripBotCordPromptScaffolding", () => {
       "",
       "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.",
       "",
+      "Before replying NO_REPLY in a non-owner group room, consider whether this message could match a memory-backed monitoring rule, automation goal, pending task, keyword, sender rule, or owner-approved workflow. If needed, use the botcord_memory skill to retrieve or update working memory.",
+      "",
       '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__/provision.test.ts

@@ -265,6 +265,8 @@ describe("wake_agent handler", () => {
         message: "【BotCord 自主任务】执行本轮工作目标。",
         run_id: "sr_test",
         schedule_id: "sch_test",
+        scheduled_for: "2026-05-19T01:30:00+00:00",
+        dispatched_at: "2026-05-19T01:30:02+00:00",
         dedupe_key: "sch_test:1:auto",
       },
     });
@@ -279,6 +281,14 @@ describe("wake_agent handler", () => {
     expect(msg.sender.kind).toBe("system");
     expect(msg.text).toContain("BotCord 自主任务");
     expect(msg.conversation.threadId).toBe("sch_test");
+    expect(msg.raw).toMatchObject({
+      source_type: "botcord_schedule",
+      schedule_id: "sch_test",
+      scheduled_for: "2026-05-19T01:30:00+00:00",
+      dispatched_at: "2026-05-19T01:30:02+00:00",
+      run_id: "sr_test",
+      dedupe_key: "sch_test:1:auto",
+    });
   });
 
   it("rejects wake_agent for an unloaded agent", async () => {

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

@@ -37,6 +37,8 @@ describe("composeBotCordUserTurn", () => {
     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("botcord_memory");
+    expect(out).toContain("retrieve or update working memory");
     expect(out).toContain('"NO_REPLY"');
   });
 
@@ -97,6 +99,31 @@ describe("composeBotCordUserTurn", () => {
     expect(out).not.toContain("do NOT reply unless");
   });
 
+  it("renders schedule timing metadata for proactive schedule turns", () => {
+    const out = composeBotCordUserTurn(
+      makeMessage({
+        conversation: { id: "rm_schedule_ag_me", kind: "direct", title: "BotCord Scheduler", threadId: "sch_daily" },
+        sender: { id: "hub", name: "BotCord Scheduler", kind: "system" },
+        text: "daily brief",
+        mentioned: true,
+        raw: {
+          source_type: "botcord_schedule",
+          schedule_id: "sch_daily",
+          scheduled_for: "2026-05-19T01:30:00+00:00",
+          dispatched_at: "2026-05-19T01:30:02+00:00",
+          run_id: "sr_daily",
+        },
+      }),
+    );
+    expect(out).toContain("[BotCord Schedule]");
+    expect(out).toContain("This turn was triggered by a proactive schedule.");
+    expect(out).toContain("schedule_id: sch_daily");
+    expect(out).toContain("scheduled_for: 2026-05-19T01:30:00+00:00");
+    expect(out).toContain("dispatched_at: 2026-05-19T01:30:02+00:00");
+    expect(out).toContain("run_id: sr_daily");
+    expect(out.indexOf("[BotCord Schedule]")).toBeLessThan(out.indexOf("<agent-message"));
+  });
+
   it("keeps the botcord_send delivery hint for non-owner BotCord rooms", () => {
     const out = composeBotCordUserTurn(
       makeMessage({

package/src/agent-workspace.ts

@@ -32,6 +32,7 @@ import {
 import { createRequire } from "node:module";
 import { homedir } from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 
 const require = createRequire(import.meta.url);
 
@@ -397,9 +398,23 @@ export function ensureAgentHermesWorkspace(
  * Seeded fresh per `ensureAgent*` call (force-overwrite) so daemon
  * upgrades propagate.
  */
-const BUNDLED_SKILLS = ["botcord", "botcord-user-guide"] as const;
+const BUNDLED_SKILLS = ["botcord", "botcord-user-guide", "botcord_memory"] as const;
+
+function resolveRepoCliSkillsRoot(): string | null {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 6; i += 1) {
+    const candidate = path.join(dir, "cli", "skills");
+    if (existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
 
 function resolveBundledCliSkillsRoot(): string | null {
+  const repoRoot = resolveRepoCliSkillsRoot();
+  if (repoRoot) return repoRoot;
   try {
     const pkgJsonPath = require.resolve("@botcord/cli/package.json");
     const root = path.join(path.dirname(pkgJsonPath), "skills");

package/src/gateway/gateway.ts

@@ -13,6 +13,7 @@ import type {
   GatewayChannelConfig,
   GatewayConfig,
   GatewayInboundMessage,
+  GatewayOutboundMessage,
   GatewayRoute,
   GatewayRuntimeSnapshot,
   InboundObserver,
@@ -271,4 +272,17 @@ export class Gateway {
   async injectInbound(message: GatewayInboundMessage): Promise<void> {
     await this.dispatcher.handle({ message });
   }
+
+  /**
+   * Send a daemon-control initiated outbound message through a registered
+   * channel. Used by proactive third-party gateway sends where the runtime
+   * explicitly targets an external provider conversation.
+   */
+  async sendOutbound(message: GatewayOutboundMessage): Promise<{ providerMessageId?: string | null }> {
+    const channel = this.channelMap.get(message.channel);
+    if (!channel) {
+      throw new Error(`channel "${message.channel}" is not registered`);
+    }
+    return channel.send({ message, log: this.log });
+  }
 }

package/src/gateway-control.ts

@@ -176,6 +176,20 @@ interface GatewayRecentSendersResult {
   senders: GatewayRecentSender[];
 }
 
+interface GatewaySendParams {
+  agentId: string;
+  gatewayId: string;
+  conversationId: string;
+  text: string;
+  idempotencyKey?: string;
+}
+
+interface GatewaySendResult {
+  gatewayId: string;
+  conversationId: string;
+  providerMessageId?: string | null;
+}
+
 export type { FetchLike };
 
 export interface GatewayControlContext {
@@ -927,6 +941,80 @@ export function createGatewayControl(ctx: GatewayControlContext) {
     }
   }
 
+  // --- gateway_send -------------------------------------------------------
+  async function handleSend(params: GatewaySendParams): Promise<AckBody> {
+    if (!params.agentId || typeof params.agentId !== "string") {
+      return badParams("gateway_send: agentId is required");
+    }
+    if (!params.gatewayId || typeof params.gatewayId !== "string") {
+      return badParams("gateway_send: gatewayId is required");
+    }
+    if (!params.conversationId || typeof params.conversationId !== "string") {
+      return badParams("gateway_send: conversationId is required");
+    }
+    if (typeof params.text !== "string" || params.text.length === 0) {
+      return badParams("gateway_send: text is required");
+    }
+
+    const cfg = cfgIO.load();
+    const profile = (cfg.thirdPartyGateways ?? []).find((g) => g.id === params.gatewayId);
+    if (!profile) {
+      return {
+        ok: false,
+        error: { code: "unknown_gateway", message: `no gateway with id "${params.gatewayId}"` },
+      };
+    }
+    if (profile.accountId !== params.agentId) {
+      return {
+        ok: false,
+        error: { code: "account_mismatch", message: "gateway is bound to a different agent" },
+      };
+    }
+    if (profile.enabled === false) {
+      return {
+        ok: false,
+        error: { code: "gateway_disabled", message: "gateway is disabled" },
+      };
+    }
+    if (profile.type === "wechat") {
+      return {
+        ok: false,
+        error: { code: "unsupported_provider", message: "wechat gateway_send requires an inbound context_token and is not supported" },
+      };
+    }
+
+    const conversationErr = validateOutboundConversation(profile, params.conversationId);
+    if (conversationErr) return conversationErr;
+
+    try {
+      const sendResult = await ctx.gateway.sendOutbound({
+        channel: params.gatewayId,
+        accountId: params.agentId,
+        conversationId: params.conversationId,
+        text: params.text,
+        traceId: `gateway-send:${params.idempotencyKey ?? Date.now()}`,
+      });
+      const result: GatewaySendResult = {
+        gatewayId: params.gatewayId,
+        conversationId: params.conversationId,
+        providerMessageId: sendResult.providerMessageId ?? null,
+      };
+      return { ok: true, result };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      daemonLog.warn("gateway_send failed", {
+        gatewayId: params.gatewayId,
+        accountId: params.agentId,
+        conversationId: params.conversationId,
+        error: message,
+      });
+      return {
+        ok: false,
+        error: { code: "send_failed", message },
+      };
+    }
+  }
+
   return {
     handleList,
     handleUpsert,
@@ -935,6 +1023,7 @@ export function createGatewayControl(ctx: GatewayControlContext) {
     handleLoginStart,
     handleLoginStatus,
     handleRecentSenders,
+    handleSend,
     /** Exposed for tests — direct access to the in-memory session map. */
     _sessions: sessions,
   };
@@ -959,6 +1048,55 @@ function validateUpsertParams(p: UpsertGatewayParams): string | null {
   return null;
 }
 
+function validateOutboundConversation(
+  profile: ThirdPartyGatewayProfile,
+  conversationId: string,
+): AckBody | null {
+  const chatId = chatIdFromConversation(profile.type, conversationId);
+  if (!chatId) {
+    return {
+      ok: false,
+      error: {
+        code: "bad_conversation",
+        message: `conversationId "${conversationId}" is not valid for ${profile.type}`,
+      },
+    };
+  }
+  const allowed = new Set((profile.allowedChatIds ?? []).map(String));
+  if (!allowed.has(chatId)) {
+    return {
+      ok: false,
+      error: {
+        code: "conversation_not_allowed",
+        message: "conversation is not in the gateway allowedChatIds list",
+      },
+    };
+  }
+  return null;
+}
+
+function chatIdFromConversation(provider: ThirdPartyGatewayProfile["type"], conversationId: string): string | null {
+  if (provider === "telegram") {
+    if (conversationId.startsWith("telegram:user:")) {
+      return conversationId.slice("telegram:user:".length);
+    }
+    if (conversationId.startsWith("telegram:group:")) {
+      return conversationId.slice("telegram:group:".length);
+    }
+    return null;
+  }
+  if (provider === "feishu") {
+    if (conversationId.startsWith("feishu:user:")) {
+      return conversationId.slice("feishu:user:".length);
+    }
+    if (conversationId.startsWith("feishu:chat:")) {
+      return conversationId.slice("feishu:chat:".length);
+    }
+    return null;
+  }
+  return null;
+}
+
 function annotateProfile(
   p: ThirdPartyGatewayProfile,
   status: import("./gateway/index.js").ChannelStatusSnapshot | undefined,

package/src/loop-risk.ts

@@ -90,6 +90,9 @@ export function stripBotCordPromptScaffolding(text: string): string {
       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("Before replying NO_REPLY in a non-owner group room")) return false;
+      if (line.startsWith("match a memory-backed monitoring rule")) return false;
+      if (line.startsWith("or owner-approved workflow. If needed")) 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;

package/src/provision.ts

@@ -400,6 +400,16 @@ export function createProvisioner(opts: ProvisionerOptions): (
         );
       }
 
+      case "gateway_send": {
+        const v = validateGatewayParams(frame.params, {
+          required: ["agentId", "gatewayId", "conversationId", "text"],
+        });
+        if (!v.ok) return v.ack;
+        return gatewayControl.handleSend(
+          v.params as unknown as Parameters<typeof gatewayControl.handleSend>[0],
+        );
+      }
+
       case "list_agent_files": {
         const params = (frame.params ?? {}) as unknown as ListAgentFilesParams;
         if (!params.agentId) {
@@ -467,6 +477,10 @@ interface WakeAgentParams {
   runId?: string;
   schedule_id?: string;
   scheduleId?: string;
+  scheduled_for?: string;
+  scheduledFor?: string;
+  dispatched_at?: string;
+  dispatchedAt?: string;
   dedupe_key?: string;
   dedupeKey?: string;
 }
@@ -504,6 +518,8 @@ async function handleWakeAgent(gateway: Gateway, raw: unknown): Promise<AckBody>
 
   const runId = params.run_id || params.runId || `wake-${Date.now()}`;
   const scheduleId = params.schedule_id || params.scheduleId;
+  const scheduledFor = params.scheduled_for || params.scheduledFor;
+  const dispatchedAt = params.dispatched_at || params.dispatchedAt;
   const dedupeKey = params.dedupe_key || params.dedupeKey;
   const conversationId = `rm_schedule_${agentId}`;
   const msg: GatewayInboundMessage = {
@@ -525,6 +541,8 @@ async function handleWakeAgent(gateway: Gateway, raw: unknown): Promise<AckBody>
     raw: {
       source_type: "botcord_schedule",
       schedule_id: scheduleId,
+      scheduled_for: scheduledFor,
+      dispatched_at: dispatchedAt,
       run_id: runId,
       dedupe_key: dedupeKey,
     },

package/src/turn-text.ts

@@ -39,6 +39,10 @@ const GROUP_HINT =
   "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" +
+  "Before replying NO_REPLY in a non-owner group room, consider whether this message could " +
+  "match a memory-backed monitoring rule, automation goal, pending task, keyword, sender rule, " +
+  "or owner-approved workflow. If needed, use the botcord_memory skill to retrieve or update " +
+  "working memory.\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, ' +
@@ -120,6 +124,41 @@ interface RoomContextRaw {
   my_can_send?: unknown;
 }
 
+interface ScheduleRaw {
+  source_type?: unknown;
+  schedule_id?: unknown;
+  scheduled_for?: unknown;
+  dispatched_at?: unknown;
+  run_id?: unknown;
+}
+
+function formatScheduleContext(raw: unknown): string[] {
+  const r = raw && typeof raw === "object" ? (raw as ScheduleRaw) : {};
+  if (r.source_type !== "botcord_schedule") return [];
+
+  const fields: string[] = [];
+  if (typeof r.schedule_id === "string" && r.schedule_id) {
+    fields.push(`schedule_id: ${sanitizeSenderName(r.schedule_id)}`);
+  }
+  if (typeof r.scheduled_for === "string" && r.scheduled_for) {
+    fields.push(`scheduled_for: ${sanitizeSenderName(r.scheduled_for)}`);
+  }
+  if (typeof r.dispatched_at === "string" && r.dispatched_at) {
+    fields.push(`dispatched_at: ${sanitizeSenderName(r.dispatched_at)}`);
+  }
+  if (typeof r.run_id === "string" && r.run_id) {
+    fields.push(`run_id: ${sanitizeSenderName(r.run_id)}`);
+  }
+
+  return fields.length > 0
+    ? [
+        "[BotCord Schedule]",
+        "This turn was triggered by a proactive schedule.",
+        fields.join(" | "),
+      ]
+    : ["[BotCord Schedule]", "This turn was triggered by a proactive schedule."];
+}
+
 /**
  * Read the `raw.batch` array emitted by the BotCord channel when inbox
  * drain groups multiple messages for the same `(room, topic)`. Returns the
@@ -256,6 +295,7 @@ export function composeBotCordUserTurn(msg: GatewayInboundMessage): string {
 
   const lines: string[] = [
     headerFields.join(" | "),
+    ...formatScheduleContext(msg.raw),
     ...(isGroup ? formatRoomContext(msg.raw, { id: conversation.id, title: roomTitle }) : []),
     `<${tag} sender="${sanitizedSenderLabel}" sender_kind="${senderKindAttr}">`,
     trimmed,