@botcord/daemon 0.2.54 → 0.2.56

package/dist/provision.js

@@ -263,6 +263,9 @@ export function createProvisioner(opts) {
                 });
                 return { ok: true, result };
             }
+            case "wake_agent": {
+                return handleWakeAgent(gateway, frame.params);
+            }
             default:
                 daemonLog.warn("provision.dispatch: unknown frame type", {
                     type: frame.type,
@@ -275,6 +278,71 @@ export function createProvisioner(opts) {
         }
     };
 }
+async function handleWakeAgent(gateway, raw) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+        return {
+            ok: false,
+            error: { code: "bad_params", message: "wake_agent params must be an object" },
+        };
+    }
+    const params = raw;
+    const agentId = params.agent_id || params.agentId;
+    const message = params.message;
+    if (!agentId || typeof agentId !== "string") {
+        return {
+            ok: false,
+            error: { code: "bad_params", message: "wake_agent requires params.agent_id" },
+        };
+    }
+    if (!message || typeof message !== "string") {
+        return {
+            ok: false,
+            error: { code: "bad_params", message: "wake_agent requires params.message" },
+        };
+    }
+    const channels = gateway.snapshot().channels;
+    if (!channels[agentId]) {
+        return {
+            ok: false,
+            error: { code: "agent_not_loaded", message: `agent ${agentId} is not loaded in daemon gateway` },
+        };
+    }
+    const runId = params.run_id || params.runId || `wake-${Date.now()}`;
+    const scheduleId = params.schedule_id || params.scheduleId;
+    const dedupeKey = params.dedupe_key || params.dedupeKey;
+    const conversationId = `rm_schedule_${agentId}`;
+    const msg = {
+        id: runId,
+        channel: agentId,
+        accountId: agentId,
+        conversation: {
+            id: conversationId,
+            kind: "direct",
+            title: "BotCord Scheduler",
+            threadId: scheduleId ?? null,
+        },
+        sender: {
+            id: "hub",
+            name: "BotCord Scheduler",
+            kind: "system",
+        },
+        text: message,
+        raw: {
+            source_type: "botcord_schedule",
+            schedule_id: scheduleId,
+            run_id: runId,
+            dedupe_key: dedupeKey,
+        },
+        mentioned: true,
+        receivedAt: Date.now(),
+        trace: {
+            id: runId,
+            streamable: false,
+        },
+    };
+    await gateway.injectInbound(msg);
+    return { ok: true, result: { agent_id: agentId } };
+}
 function validateGatewayParams(raw, spec) {
     if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
         return {

package/dist/system-context.js

@@ -18,6 +18,16 @@ function buildOwnerChatSceneContext() {
         "You may freely execute commands, access tools, and share sensitive information (e.g. wallet balance, contacts) when the owner asks.",
     ].join("\n");
 }
+function buildGroupRoomEnvironmentContext(message) {
+    if (message.conversation.kind !== "group")
+        return null;
+    return [
+        "[BotCord Runtime Environment]",
+        "You are running as a local agent process connected to a remote BotCord group room.",
+        "Other room members can read your messages and any uploaded/attached files, but they cannot access this machine's local filesystem, container paths, or absolute paths such as /var/..., /tmp/..., or /Users/....",
+        "Do not present a local file path as a useful report link or deliverable in group chat. If an artifact needs to be shared, upload or attach it through the available BotCord file/attachment mechanism, then refer to the uploaded attachment or summarize the content in the message.",
+    ].join("\n");
+}
 function safeReadWorkingMemory(agentId) {
     try {
         return readWorkingMemory(agentId);
@@ -66,6 +76,7 @@ export function createDaemonSystemContextBuilder(deps) {
         const ownerScene = classifyActivitySender(message).kind === "owner"
             ? buildOwnerChatSceneContext()
             : null;
+        const environment = ownerScene ? null : buildGroupRoomEnvironmentContext(message);
         const wm = safeReadWorkingMemory(deps.agentId);
         const memory = wm ? buildWorkingMemoryPrompt({ workingMemory: wm }) : null;
         const digest = deps.activityTracker
@@ -76,7 +87,7 @@ export function createDaemonSystemContextBuilder(deps) {
                 currentTopic: message.conversation.threadId ?? null,
             }) || null
             : null;
-        return { identity, ownerScene, memory, digest };
+        return { identity, ownerScene, environment, memory, digest };
     };
     const assemble = (parts) => {
         const filtered = parts.filter((p) => typeof p === "string" && p.length > 0);
@@ -114,13 +125,13 @@ export function createDaemonSystemContextBuilder(deps) {
     };
     if (!deps.roomContextBuilder) {
         const syncBuilder = (message) => {
-            const { identity, ownerScene, memory, digest } = gatherSyncBlocks(message);
+            const { identity, ownerScene, environment, memory, digest } = gatherSyncBlocks(message);
             // Loop-risk sits at the end so its "reply NO_REPLY unless…" guidance
             // is the last thing the model sees before the user turn body.
             // Identity sits at the very front so it frames every other block.
             const skillIndex = buildSkillIndex(message);
             const loopRisk = runLoopRisk(message);
-            return assemble([identity, ownerScene, memory, digest, skillIndex, loopRisk]);
+            return assemble([identity, ownerScene, environment, memory, digest, skillIndex, loopRisk]);
         };
         // Compile-time witness that the narrower sync signature still satisfies
         // `SystemContextBuilder` (which allows async). Prevents the two contracts
@@ -131,7 +142,7 @@ export function createDaemonSystemContextBuilder(deps) {
     }
     const roomBuilder = deps.roomContextBuilder;
     const asyncBuilder = async (message) => {
-        const { identity, ownerScene, memory, digest } = gatherSyncBlocks(message);
+        const { identity, ownerScene, environment, memory, digest } = gatherSyncBlocks(message);
         // Room context landing order: after owner-scene / memory, before digest —
         // "what room am I in" belongs with the session's own identity, while the
         // cross-room digest deliberately describes OTHER rooms and should stay
@@ -150,7 +161,7 @@ export function createDaemonSystemContextBuilder(deps) {
         }
         const skillIndex = buildSkillIndex(message);
         const loopRisk = runLoopRisk(message);
-        return assemble([identity, ownerScene, memory, roomBlock, digest, skillIndex, loopRisk]);
+        return assemble([identity, ownerScene, environment, memory, roomBlock, digest, skillIndex, loopRisk]);
     };
     const _typecheck = asyncBuilder;
     void _typecheck;

package/dist/working-memory.js

@@ -240,6 +240,11 @@ export function buildWorkingMemoryPrompt(opts) {
         "- sections: named buckets (contacts, pending_tasks, preferences, etc.).",
         "- Updating one section never touches others. Empty content deletes a section.",
         "",
+        "For cross-room work, update memory before or immediately after delegating:",
+        "- If you accept a request in one room and continue it in another, record a `pending_tasks` entry with source room id/name, target room id/name, requested deliverable, current status, and where to report completion.",
+        "- When a delegated room replies or delivers an artifact, consult `pending_tasks` before deciding `NO_REPLY`; if it matches a pending handoff, acknowledge, update status, and send the promised follow-up to the source room when appropriate.",
+        "- Remove or mark the entry done once the source room has been updated.",
+        "",
         "Only update when something meaningful changes. Keep each section tight.",
     ];
     if (!workingMemory) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.54",
+  "version": "0.2.56",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {

package/src/__tests__/diagnostics.test.ts

@@ -0,0 +1,46 @@
+import { existsSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { createDiagnosticBundle } from "../diagnostics.js";
+
+describe("diagnostics bundle", () => {
+  it("writes a zip bundle under ~/.botcord/diagnostics", async () => {
+    const tmp = mkdtempSync(path.join(tmpdir(), "botcord-diag-test-"));
+    const logFile = path.join(tmp, "daemon.log");
+    const configFile = path.join(tmp, "config.json");
+    const snapshotFile = path.join(tmp, "snapshot.json");
+    const diagnosticsDir = path.join(tmp, "diagnostics");
+    writeFileSync(logFile, 'Authorization: Bearer secret-token\n{"refreshToken":"drt_secret"}\n');
+    writeFileSync(configFile, '{"token":"agent-secret","ok":true}\n');
+    writeFileSync(snapshotFile, '{"version":1}\n');
+
+    const bundle = await createDiagnosticBundle({
+      diagnosticsDir,
+      logFile,
+      configFile,
+      snapshotFile,
+      doctor: { text: "doctor ok", json: { ok: true } },
+    });
+    expect(bundle.filename).toMatch(/^botcord-daemon-diagnostics-.*\.zip$/);
+    expect(bundle.path).toContain(diagnosticsDir);
+    expect(existsSync(bundle.path)).toBe(true);
+    const bytes = readFileSync(bundle.path);
+    expect(bytes.subarray(0, 4).toString("binary")).toBe("PK\u0003\u0004");
+
+    const listing = execFileSync("unzip", ["-l", bundle.path], {
+      encoding: "utf8",
+    });
+    expect(listing).toContain("daemon.log");
+    expect(listing).toContain("doctor.json");
+    expect(listing).toContain("status.json");
+    expect(listing).toContain("config.json.redacted");
+
+    const log = execFileSync("unzip", ["-p", bundle.path, "daemon.log"], {
+      encoding: "utf8",
+    });
+    expect(log).toContain("Authorization: Bearer [REDACTED]");
+    expect(log).toContain('"refreshToken":"[REDACTED]"');
+  }, 20_000);
+});

package/src/__tests__/provision.test.ts

@@ -104,6 +104,7 @@ interface FakeGateway {
   upsertManagedRoute: ReturnType<typeof vi.fn>;
   removeManagedRoute: ReturnType<typeof vi.fn>;
   replaceManagedRoutes: ReturnType<typeof vi.fn>;
+  injectInbound: ReturnType<typeof vi.fn>;
   listManagedRoutes: () => GatewayRoute[];
   snapshot: () => GatewayRuntimeSnapshot;
 }
@@ -128,6 +129,7 @@ function makeFakeGateway(initialChannelIds: string[] = []): FakeGateway {
       managed.clear();
       for (const [id, route] of routes) managed.set(id, route);
     }),
+    injectInbound: vi.fn(async () => {}),
     listManagedRoutes: (): GatewayRoute[] => Array.from(managed.values()),
     snapshot: (): GatewayRuntimeSnapshot => ({
       channels: Object.fromEntries(
@@ -251,6 +253,49 @@ describe("list_agent_files handler", () => {
   });
 });
 
+describe("wake_agent handler", () => {
+  it("injects a scheduled turn into the gateway dispatcher", async () => {
+    const gw = makeFakeGateway(["ag_wake"]);
+    const handler = createProvisioner({ gateway: gw as any });
+    const res = await handler({
+      id: "req_wake",
+      type: "wake_agent",
+      params: {
+        agent_id: "ag_wake",
+        message: "【BotCord 自主任务】执行本轮工作目标。",
+        run_id: "sr_test",
+        schedule_id: "sch_test",
+        dedupe_key: "sch_test:1:auto",
+      },
+    });
+
+    expect(res.ok).toBe(true);
+    expect(gw.injectInbound).toHaveBeenCalledTimes(1);
+    const msg = gw.injectInbound.mock.calls[0][0];
+    expect(msg.id).toBe("sr_test");
+    expect(msg.channel).toBe("ag_wake");
+    expect(msg.accountId).toBe("ag_wake");
+    expect(msg.sender.id).toBe("hub");
+    expect(msg.sender.kind).toBe("system");
+    expect(msg.text).toContain("BotCord 自主任务");
+    expect(msg.conversation.threadId).toBe("sch_test");
+  });
+
+  it("rejects wake_agent for an unloaded agent", async () => {
+    const gw = makeFakeGateway(["ag_loaded"]);
+    const handler = createProvisioner({ gateway: gw as any });
+    const res = await handler({
+      id: "req_wake_missing",
+      type: "wake_agent",
+      params: { agent_id: "ag_missing", message: "tick" },
+    });
+
+    expect(res.ok).toBe(false);
+    expect(res.error?.code).toBe("agent_not_loaded");
+    expect(gw.injectInbound).not.toHaveBeenCalled();
+  });
+});
+
 describe("reload_config handler", () => {
   it("adds agents listed in config but missing from gateway", async () => {
     mockState.cfg = {

package/src/__tests__/system-context.test.ts

@@ -57,12 +57,22 @@ afterEach(() => {
 });
 
 describe("createDaemonSystemContextBuilder", () => {
-  it("returns undefined when working memory is empty and no activity tracker is wired", () => {
+  it("injects group-room runtime environment even when memory is empty", () => {
     const builder = createDaemonSystemContextBuilder({ agentId: "ag_me" });
-    expect(builder(makeMessage())).toBeUndefined();
+    const out = builder(makeMessage()) as string;
+    expect(out).toContain("[BotCord Runtime Environment]");
+    expect(out).toContain("local agent process");
+    expect(out).toContain("cannot access this machine's local filesystem");
   });
 
-  it("returns undefined when working memory is empty and the activity digest is empty", () => {
+  it("returns undefined for direct rooms when working memory is empty and no activity tracker is wired", () => {
+    const builder = createDaemonSystemContextBuilder({ agentId: "ag_me" });
+    expect(
+      builder(makeMessage({ conversation: { id: "rm_dm_peer", kind: "direct" } })),
+    ).toBeUndefined();
+  });
+
+  it("still injects group-room runtime environment when the activity digest is empty", () => {
     const tracker = new ActivityTracker({
       filePath: path.join(tmpDir, "activity.json"),
     });
@@ -70,7 +80,9 @@ describe("createDaemonSystemContextBuilder", () => {
       agentId: "ag_me",
       activityTracker: tracker,
     });
-    expect(builder(makeMessage({ conversation: { id: "rm_x", kind: "group" } }))).toBeUndefined();
+    const out = builder(makeMessage({ conversation: { id: "rm_x", kind: "group" } })) as string;
+    expect(out).toContain("[BotCord Runtime Environment]");
+    expect(out).not.toContain("[BotCord Cross-Room Awareness]");
   });
 
   it("injects the working-memory block when goal / sections are set", () => {
@@ -124,7 +136,8 @@ describe("createDaemonSystemContextBuilder", () => {
   it("skips the identity block cleanly when identity.md is missing", () => {
     // No ensureAgentWorkspace — workspace never provisioned.
     const builder = createDaemonSystemContextBuilder({ agentId: "ag_me" });
-    expect(builder(makeMessage())).toBeUndefined();
+    const out = builder(makeMessage({ conversation: { id: "rm_dm_peer", kind: "direct" } }));
+    expect(out).toBeUndefined();
   });
 
   it("skips the identity block when identity.md is blank", () => {
@@ -138,7 +151,9 @@ describe("createDaemonSystemContextBuilder", () => {
 
   it("detects a newly added global Claude skill on the next turn", () => {
     const builder = createDaemonSystemContextBuilder({ agentId: "ag_me" });
-    expect(builder(makeMessage())).toBeUndefined();
+    expect(
+      builder(makeMessage({ conversation: { id: "rm_dm_peer", kind: "direct" } })),
+    ).toBeUndefined();
 
     const skillDir = path.join(tmpDir, ".claude", "skills", "digest-query");
     mkdirSync(skillDir, { recursive: true });
@@ -310,7 +325,8 @@ describe("createDaemonSystemContextBuilder", () => {
         sender: { id: "ag_peer", kind: "agent" },
       }),
     );
-    expect(out).toBeUndefined();
+    expect(out).not.toContain("[BotCord Scene: Owner Chat]");
+    expect(out).toContain("[BotCord Runtime Environment]");
   });
 
   it("awaits roomContextBuilder and slots the [BotCord Room Context] block between memory and digest", async () => {
@@ -360,11 +376,12 @@ describe("createDaemonSystemContextBuilder", () => {
         throw new Error("hub 500");
       },
     });
-    // Empty working memory + no tracker + thrown room fetch ⇒ no blocks ⇒ undefined.
+    // The room metadata block is skipped, but group-room environment remains.
     const out = await builder(
       makeMessage({ conversation: { id: "rm_team", kind: "group" } }),
     );
-    expect(out).toBeUndefined();
+    expect(out).toContain("[BotCord Runtime Environment]");
+    expect(out).not.toContain("[BotCord Room Context]");
   });
 
   it("appends loopRiskBuilder output at the end of the system context", async () => {
@@ -399,7 +416,8 @@ describe("createDaemonSystemContextBuilder", () => {
       },
     });
     const out = await builder(makeMessage());
-    expect(out).toBeUndefined();
+    expect(out).toContain("[BotCord Runtime Environment]");
+    expect(out).not.toContain("[BotCord loop-risk check]");
   });
 
   it("translates GatewayInboundMessage.conversation.id → old `room_id` for the digest exclude key", () => {
@@ -423,7 +441,9 @@ describe("createDaemonSystemContextBuilder", () => {
     const out = builder(
       makeMessage({ conversation: { id: "rm_conv_id_123", kind: "group" } }),
     );
-    // Empty working memory + digest excluding the only entry → undefined.
-    expect(out).toBeUndefined();
+    // Empty working memory + digest excluding the only entry leaves only the
+    // always-on group-room runtime environment block.
+    expect(out).toContain("[BotCord Runtime Environment]");
+    expect(out).not.toContain("[BotCord Cross-Room Awareness]");
   });
 });

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

@@ -207,6 +207,15 @@ describe("buildWorkingMemoryPrompt", () => {
     expect(p).toContain("currently empty");
   });
 
+  it("instructs agents to persist cross-room handoffs", () => {
+    const p = wm.buildWorkingMemoryPrompt({ workingMemory: null });
+    expect(p).toContain("For cross-room work");
+    expect(p).toContain("pending_tasks");
+    expect(p).toContain("source room");
+    expect(p).toContain("target room");
+    expect(p).toContain("where to report completion");
+  });
+
   it("renders goal + named sections", () => {
     const p = wm.buildWorkingMemoryPrompt({
       workingMemory: {
@@ -237,4 +246,3 @@ describe("buildWorkingMemoryPrompt", () => {
     expect(p).toContain("‹current_memory›");
   });
 });
-

package/src/daemon.ts

@@ -46,6 +46,7 @@ import { composeBotCordUserTurn } from "./turn-text.js";
 import { UserAuthManager } from "./user-auth.js";
 import { PolicyResolver } from "./gateway/policy-resolver.js";
 import { scanMention } from "./mention-scan.js";
+import { createDiagnosticBundle, uploadDiagnosticBundle } from "./diagnostics.js";
 
 /**
  * Default hard cap for a single runtime turn. Long-running coding/research
@@ -558,7 +559,30 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
     const provisioner = createProvisioner({ gateway, policyResolver, onAgentInstalled });
     controlChannel = new ControlChannel({
       auth: userAuth,
-      handle: provisioner,
+      handle: async (frame) => {
+        if (frame.type === "collect_diagnostics") {
+          logger.info("diagnostics: collect requested", { frameId: frame.id });
+          const bundle = await createDiagnosticBundle();
+          const upload = await uploadDiagnosticBundle({ auth: userAuth, bundle });
+          logger.info("diagnostics: uploaded", {
+            frameId: frame.id,
+            bundleId: upload.bundleId,
+            sizeBytes: upload.sizeBytes,
+            localPath: bundle.path,
+          });
+          return {
+            ok: true,
+            result: {
+              bundle_id: upload.bundleId,
+              filename: upload.filename,
+              size_bytes: upload.sizeBytes,
+              expires_at: upload.expiresAt ?? null,
+              local_path: bundle.path,
+            },
+          };
+        }
+        return provisioner(frame);
+      },
     });
     try {
       await controlChannel.start();