opensquid 0.5.395

package/dist/chat/daemon/routing.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Per-project chat routing (v0.7.1 Phase C).
+ *
+ * Note on src.legacy/ placement (TG.1 (f) / WAB.2): the "legacy" label is a
+ * pre-0.5.x architecture marker, NOT a "dead code" marker. The chat-daemon
+ * compiled from `src.legacy/chat/` is the production runtime for inbound
+ * Telegram + outbound chat_send. This file is actively maintained — see
+ * `inbound_dm_user_ids` (v0.5.94 / WAB.2 Part A) below.
+ *
+ * Schema on disk: `~/.opensquid/projects/<uuid>/chat-routing.json`
+ *
+ * ```jsonc
+ * {
+ *   "telegram": {
+ *     "report_channel": "telegram:-1001234567890",  // outbound default
+ *     "report_topic_id": 15,                          // forum-topic id for outbound
+ *     "inbound_chat_ids": ["-1001234567890"],        // accepts inbound from these chats
+ *     "inbound_topic_ids": [15],                      // strict whitelist when set
+ *     "inbound_dm_user_ids": ["8075471258"]          // v0.5.94 — DM allowlist
+ *   },
+ *   "discord": {
+ *     "report_channel": "discord:1234567890",
+ *     "inbound_channel_ids": ["1234567890"]
+ *   },
+ *   "slack": {
+ *     "report_channel": "slack:C012345",
+ *     "inbound_channel_ids": ["C012345"]
+ *   }
+ * }
+ * ```
+ *
+ * Routing rules:
+ *   - **Outbound** (agent → chat): the MCP tool picks `report_channel`
+ *     from the active project's routing config. (Phase E wires the MCP
+ *     tools; this module just exposes the lookup.)
+ *   - **Inbound** (chat → agent): the daemon's gateway.onMessage handler
+ *     constructs a routing key (DM key, topic key, or chat-only key per
+ *     TG.1 policy decision (a)+(d)) and looks it up in the index this
+ *     module builds. Match → JSONL append to that project's inbox.
+ *     No match → JSONL append to the orphan inbox.
+ *
+ * UUID is the stable primary key because the project's human-friendly
+ * `id` can be renamed via `opensquid project init` without rewriting
+ * routing files.
+ */
+export interface TelegramRouting {
+    report_channel?: string;
+    /**
+     * v0.7.2 — forum-topic id within the supergroup (`report_channel`)
+     * that outbound reports for this project should post to. When set,
+     * outbound `chat_send` via `project:telegram` includes the
+     * `message_thread_id` so the message lands in the right topic.
+     */
+    report_topic_id?: number;
+    inbound_chat_ids?: string[];
+    /**
+     * v0.7.2 — when set, ONLY inbound messages with one of these
+     * `message_thread_id` values route to this project. Empty/unset means
+     * accept any topic (legacy v0.7.1 behavior — accepts all messages
+     * from the listed `inbound_chat_ids`).
+     */
+    inbound_topic_ids?: number[];
+    /**
+     * v0.5.94 (WAB.2 Part A / TG.1 decision (a)) — allowlist of user IDs
+     * whose Telegram DMs route to this project. A "DM" is detected when the
+     * inbound `chat.id === from.id` (Telegram's canonical private-chat
+     * shape). On match, the routing key is `telegram:dm:<user_id>`. Group
+     * messages from the same user use `inbound_chat_ids` + topic semantics
+     * — this field does NOT shadow group routing.
+     *
+     * Schema is additive: existing chat-routing.json files without this
+     * field continue to load and route correctly (DM routing simply
+     * disabled for that project).
+     */
+    inbound_dm_user_ids?: string[];
+}
+export interface DiscordRouting {
+    report_channel?: string;
+    inbound_channel_ids?: string[];
+}
+export interface SlackRouting {
+    report_channel?: string;
+    inbound_channel_ids?: string[];
+}
+export interface ProjectChatRouting {
+    telegram?: TelegramRouting;
+    discord?: DiscordRouting;
+    slack?: SlackRouting;
+}
+/**
+ * In-memory index built from all per-project routing files. Used by
+ * the daemon's inbound handler to decide which project's inbox an
+ * incoming message belongs to.
+ *
+ * Key shape: `<platform>:<native_chat_id>` — same shape as ChannelId
+ * so the daemon can index directly off the parsed channel field of
+ * an inbound ChatMessage.
+ */
+export type RoutingIndex = Map<string, string>;
+export declare function projectsRootPath(dataRoot?: string): string;
+export declare function projectChatRoutingPath(projectUuid: string, dataRoot?: string): string;
+export declare function projectInboxDir(projectUuid: string, dataRoot?: string): string;
+export declare function orphanInboxDir(dataRoot?: string): string;
+/**
+ * Read a single project's routing config. Returns null if the file
+ * doesn't exist or fails to parse — both are non-fatal (the project
+ * just doesn't have routing configured, so inbound for it goes to
+ * the orphan inbox).
+ */
+export declare function loadProjectChatRouting(projectUuid: string, dataRoot?: string): Promise<ProjectChatRouting | null>;
+/**
+ * Scan `~/.opensquid/projects/*` and load every routing file that
+ * exists. Returns a Map keyed by project_uuid → routing config. Used
+ * by `buildRoutingIndex` to construct the lookup map.
+ */
+export declare function loadAllProjectChatRouting(dataRoot?: string): Promise<Map<string, ProjectChatRouting>>;
+/**
+ * Build the inbound chat_id → project_uuid lookup map from a collection
+ * of per-project routing configs. Used at daemon startup AND whenever
+ * the file watcher fires on a routing change.
+ *
+ * Collision handling: if two projects claim the same inbound chat_id,
+ * the LATER one wins (Map.set overwrite). Surface a warning via the
+ * optional `onWarn` callback so the operator can fix it.
+ */
+export declare function buildRoutingIndex(configs: Map<string, ProjectChatRouting>, onWarn?: (message: string) => void): RoutingIndex;
+/**
+ * Yield each inbound channel id (in `<platform>:<native_id>` shape) a
+ * routing config declares.
+ */
+export declare function collectInboundChannels(cfg: ProjectChatRouting): string[];
+/**
+ * Persist a project's routing config. Creates the project directory if
+ * missing. Atomic-ish via write-then-rename so partial writes never
+ * leave a corrupt file.
+ */
+export declare function saveProjectChatRouting(projectUuid: string, routing: ProjectChatRouting, dataRoot?: string): Promise<{
+    path: string;
+}>;
+//# sourceMappingURL=routing.d.ts.map

package/dist/chat/daemon/routing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing.d.ts","sourceRoot":"","sources":["../../../src.legacy/chat/daemon/routing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAWH,MAAM,WAAW,eAAe;IAC9B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B;;;;;;;;;;;OAWG;IACH,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,cAAc;IAC7B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,YAAY;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAoB,CAAC;AAMlE,wBAAgB,gBAAgB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAErF;AAED,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAE9E;AAED,wBAAgB,cAAc,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAExD;AAMD;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAC1C,WAAW,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAcpC;AAED;;;;GAIG;AACH,wBAAsB,yBAAyB,CAC7C,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAiB1C;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,EACxC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GACjC,YAAY,CAcd;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,kBAAkB,GAAG,MAAM,EAAE,CAgCxE;AAMD;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,kBAAkB,EAC3B,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAO3B"}

package/dist/chat/daemon/routing.js

@@ -0,0 +1,198 @@
+/**
+ * Per-project chat routing (v0.7.1 Phase C).
+ *
+ * Note on src.legacy/ placement (TG.1 (f) / WAB.2): the "legacy" label is a
+ * pre-0.5.x architecture marker, NOT a "dead code" marker. The chat-daemon
+ * compiled from `src.legacy/chat/` is the production runtime for inbound
+ * Telegram + outbound chat_send. This file is actively maintained — see
+ * `inbound_dm_user_ids` (v0.5.94 / WAB.2 Part A) below.
+ *
+ * Schema on disk: `~/.opensquid/projects/<uuid>/chat-routing.json`
+ *
+ * ```jsonc
+ * {
+ *   "telegram": {
+ *     "report_channel": "telegram:-1001234567890",  // outbound default
+ *     "report_topic_id": 15,                          // forum-topic id for outbound
+ *     "inbound_chat_ids": ["-1001234567890"],        // accepts inbound from these chats
+ *     "inbound_topic_ids": [15],                      // strict whitelist when set
+ *     "inbound_dm_user_ids": ["8075471258"]          // v0.5.94 — DM allowlist
+ *   },
+ *   "discord": {
+ *     "report_channel": "discord:1234567890",
+ *     "inbound_channel_ids": ["1234567890"]
+ *   },
+ *   "slack": {
+ *     "report_channel": "slack:C012345",
+ *     "inbound_channel_ids": ["C012345"]
+ *   }
+ * }
+ * ```
+ *
+ * Routing rules:
+ *   - **Outbound** (agent → chat): the MCP tool picks `report_channel`
+ *     from the active project's routing config. (Phase E wires the MCP
+ *     tools; this module just exposes the lookup.)
+ *   - **Inbound** (chat → agent): the daemon's gateway.onMessage handler
+ *     constructs a routing key (DM key, topic key, or chat-only key per
+ *     TG.1 policy decision (a)+(d)) and looks it up in the index this
+ *     module builds. Match → JSONL append to that project's inbox.
+ *     No match → JSONL append to the orphan inbox.
+ *
+ * UUID is the stable primary key because the project's human-friendly
+ * `id` can be renamed via `opensquid project init` without rewriting
+ * routing files.
+ */
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { resolveDataRoot } from "../../codex/store.js";
+// ---------------------------------------------------------------------
+// Paths
+// ---------------------------------------------------------------------
+export function projectsRootPath(dataRoot) {
+    return path.join(resolveDataRoot(dataRoot), "projects");
+}
+export function projectChatRoutingPath(projectUuid, dataRoot) {
+    return path.join(projectsRootPath(dataRoot), projectUuid, "chat-routing.json");
+}
+export function projectInboxDir(projectUuid, dataRoot) {
+    return path.join(projectsRootPath(dataRoot), projectUuid, "inbox");
+}
+export function orphanInboxDir(dataRoot) {
+    return path.join(resolveDataRoot(dataRoot), "inbox", "orphan");
+}
+// ---------------------------------------------------------------------
+// Load
+// ---------------------------------------------------------------------
+/**
+ * Read a single project's routing config. Returns null if the file
+ * doesn't exist or fails to parse — both are non-fatal (the project
+ * just doesn't have routing configured, so inbound for it goes to
+ * the orphan inbox).
+ */
+export async function loadProjectChatRouting(projectUuid, dataRoot) {
+    const p = projectChatRoutingPath(projectUuid, dataRoot);
+    try {
+        const raw = await fs.readFile(p, "utf8");
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        // Malformed JSON: log on stderr (daemon log) and fall back to
+        // no-routing. Better than crashing the daemon over a bad file.
+        process.stderr.write(`[chat-routing] failed to parse ${p}: ${err instanceof Error ? err.message : err}\n`);
+        return null;
+    }
+}
+/**
+ * Scan `~/.opensquid/projects/*` and load every routing file that
+ * exists. Returns a Map keyed by project_uuid → routing config. Used
+ * by `buildRoutingIndex` to construct the lookup map.
+ */
+export async function loadAllProjectChatRouting(dataRoot) {
+    const root = projectsRootPath(dataRoot);
+    const out = new Map();
+    let entries;
+    try {
+        entries = await fs.readdir(root);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return out;
+        throw err;
+    }
+    for (const uuid of entries) {
+        // Skip hidden files; only consider directory-like entries.
+        if (uuid.startsWith("."))
+            continue;
+        const routing = await loadProjectChatRouting(uuid, dataRoot);
+        if (routing)
+            out.set(uuid, routing);
+    }
+    return out;
+}
+/**
+ * Build the inbound chat_id → project_uuid lookup map from a collection
+ * of per-project routing configs. Used at daemon startup AND whenever
+ * the file watcher fires on a routing change.
+ *
+ * Collision handling: if two projects claim the same inbound chat_id,
+ * the LATER one wins (Map.set overwrite). Surface a structured warning
+ * via the optional `onCollision` callback so the operator can fix it.
+ */
+export function buildRoutingIndex(configs, onCollision) {
+    const idx = new Map();
+    for (const [projectUuid, cfg] of configs) {
+        for (const channelKey of collectInboundChannels(cfg)) {
+            const existing = idx.get(channelKey);
+            if (existing && existing !== projectUuid && onCollision) {
+                onCollision({
+                    channel_key: channelKey,
+                    existing_uuid: existing,
+                    newcomer_uuid: projectUuid,
+                });
+            }
+            idx.set(channelKey, projectUuid);
+        }
+    }
+    return idx;
+}
+/**
+ * Yield each inbound channel id (in `<platform>:<native_id>` shape) a
+ * routing config declares.
+ */
+export function collectInboundChannels(cfg) {
+    const out = [];
+    if (cfg.telegram?.inbound_chat_ids) {
+        // v0.7.2: if inbound_topic_ids is set, emit a more-specific key per
+        // (chat_id, topic_id) tuple so the routing index can distinguish
+        // multiple projects sharing one supergroup. Otherwise emit the
+        // chat-only key (v0.7.1 behavior).
+        const topicIds = cfg.telegram.inbound_topic_ids;
+        for (const chatId of cfg.telegram.inbound_chat_ids) {
+            if (topicIds && topicIds.length > 0) {
+                for (const tid of topicIds)
+                    out.push(`telegram:${chatId}:${tid}`);
+            }
+            else {
+                out.push(`telegram:${chatId}`);
+            }
+        }
+    }
+    // v0.5.94 (WAB.2 Part A / TG.1 (a)): emit DM allowlist keys as
+    // `telegram:dm:<user_id>`. Worker's onMessage detects DMs (chat.id ===
+    // from.id) and looks up against this key. Separate key namespace from
+    // `telegram:<chat_id>` so a user whose user_id collides with a
+    // supergroup chat_id (unlikely but possible — both are integers) does
+    // not silently cross-route.
+    if (cfg.telegram?.inbound_dm_user_ids) {
+        for (const uid of cfg.telegram.inbound_dm_user_ids)
+            out.push(`telegram:dm:${uid}`);
+    }
+    if (cfg.discord?.inbound_channel_ids) {
+        for (const id of cfg.discord.inbound_channel_ids)
+            out.push(`discord:${id}`);
+    }
+    if (cfg.slack?.inbound_channel_ids) {
+        for (const id of cfg.slack.inbound_channel_ids)
+            out.push(`slack:${id}`);
+    }
+    return out;
+}
+// ---------------------------------------------------------------------
+// Write
+// ---------------------------------------------------------------------
+/**
+ * Persist a project's routing config. Creates the project directory if
+ * missing. Atomic-ish via write-then-rename so partial writes never
+ * leave a corrupt file.
+ */
+export async function saveProjectChatRouting(projectUuid, routing, dataRoot) {
+    const filePath = projectChatRoutingPath(projectUuid, dataRoot);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    await fs.writeFile(tmp, `${JSON.stringify(routing, null, 2)}\n`, "utf8");
+    await fs.rename(tmp, filePath);
+    return { path: filePath };
+}

package/dist/chat/daemon/routing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing.js","sourceRoot":"","sources":["../../../src.legacy/chat/daemon/routing.ts"],"names":[],"mappings":"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"}

package/dist/chat/daemon/routing.test.js

@@ -0,0 +1,259 @@
+/**
+ * routing.ts unit tests (v0.7.1 Phase C).
+ */
+import { promises as fs } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { buildRoutingIndex, collectInboundChannels, loadAllProjectChatRouting, loadProjectChatRouting, projectChatRoutingPath, projectInboxDir, projectsRootPath, saveProjectChatRouting, } from "./routing.js";
+let tmpRoot;
+let prevHome;
+beforeEach(async () => {
+    tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), "opensquid-routing-test-"));
+    prevHome = process.env.OPENSQUID_HOME;
+    process.env.OPENSQUID_HOME = tmpRoot;
+});
+afterEach(async () => {
+    if (prevHome === undefined)
+        delete process.env.OPENSQUID_HOME;
+    else
+        process.env.OPENSQUID_HOME = prevHome;
+    await fs.rm(tmpRoot, { recursive: true, force: true });
+});
+describe("path derivation", () => {
+    it("projectsRootPath = <dataRoot>/projects", () => {
+        expect(projectsRootPath(tmpRoot)).toBe(path.join(tmpRoot, "projects"));
+    });
+    it("projectChatRoutingPath = <dataRoot>/projects/<uuid>/chat-routing.json", () => {
+        expect(projectChatRoutingPath("abc-uuid", tmpRoot)).toBe(path.join(tmpRoot, "projects", "abc-uuid", "chat-routing.json"));
+    });
+    it("projectInboxDir = <dataRoot>/projects/<uuid>/inbox", () => {
+        expect(projectInboxDir("abc-uuid", tmpRoot)).toBe(path.join(tmpRoot, "projects", "abc-uuid", "inbox"));
+    });
+});
+describe("loadProjectChatRouting", () => {
+    it("returns null when the routing file is missing", async () => {
+        const r = await loadProjectChatRouting("missing-uuid", tmpRoot);
+        expect(r).toBeNull();
+    });
+    it("loads a valid routing file", async () => {
+        const uuid = "test-uuid";
+        await fs.mkdir(path.join(tmpRoot, "projects", uuid), { recursive: true });
+        await fs.writeFile(path.join(tmpRoot, "projects", uuid, "chat-routing.json"), JSON.stringify({
+            telegram: { report_channel: "telegram:-100", inbound_chat_ids: ["-100", "-200"] },
+        }));
+        const r = await loadProjectChatRouting(uuid, tmpRoot);
+        expect(r).not.toBeNull();
+        expect(r?.telegram?.report_channel).toBe("telegram:-100");
+        expect(r?.telegram?.inbound_chat_ids).toEqual(["-100", "-200"]);
+    });
+    it("returns null on malformed JSON (does not throw)", async () => {
+        const uuid = "bad-uuid";
+        await fs.mkdir(path.join(tmpRoot, "projects", uuid), { recursive: true });
+        await fs.writeFile(path.join(tmpRoot, "projects", uuid, "chat-routing.json"), "{ not json");
+        const r = await loadProjectChatRouting(uuid, tmpRoot);
+        expect(r).toBeNull();
+    });
+});
+describe("loadAllProjectChatRouting", () => {
+    it("returns empty map when projects root doesn't exist", async () => {
+        const r = await loadAllProjectChatRouting(tmpRoot);
+        expect(r.size).toBe(0);
+    });
+    it("collects all valid routing files, skipping hidden entries", async () => {
+        const projectsDir = path.join(tmpRoot, "projects");
+        await fs.mkdir(path.join(projectsDir, "uuid-a"), { recursive: true });
+        await fs.mkdir(path.join(projectsDir, "uuid-b"), { recursive: true });
+        await fs.mkdir(path.join(projectsDir, ".hidden"), { recursive: true });
+        await fs.writeFile(path.join(projectsDir, "uuid-a", "chat-routing.json"), JSON.stringify({ telegram: { inbound_chat_ids: ["1"] } }));
+        await fs.writeFile(path.join(projectsDir, "uuid-b", "chat-routing.json"), JSON.stringify({ discord: { inbound_channel_ids: ["2"] } }));
+        await fs.writeFile(path.join(projectsDir, ".hidden", "chat-routing.json"), JSON.stringify({ slack: { inbound_channel_ids: ["3"] } }));
+        const all = await loadAllProjectChatRouting(tmpRoot);
+        expect(all.size).toBe(2);
+        expect(all.has("uuid-a")).toBe(true);
+        expect(all.has("uuid-b")).toBe(true);
+        expect(all.has(".hidden")).toBe(false);
+    });
+});
+describe("collectInboundChannels", () => {
+    it("returns empty list for empty config", () => {
+        expect(collectInboundChannels({})).toEqual([]);
+    });
+    it("formats telegram ids as telegram:<id>", () => {
+        const ch = collectInboundChannels({ telegram: { inbound_chat_ids: ["100", "200"] } });
+        expect(ch).toEqual(["telegram:100", "telegram:200"]);
+    });
+    it("collects across all platforms", () => {
+        const ch = collectInboundChannels({
+            telegram: { inbound_chat_ids: ["t1"] },
+            discord: { inbound_channel_ids: ["d1"] },
+            slack: { inbound_channel_ids: ["s1"] },
+        });
+        expect(ch).toEqual(["telegram:t1", "discord:d1", "slack:s1"]);
+    });
+});
+// v0.5.94 (WAB.2 Part A / TG.1 (a)) — DM allowlist key emission.
+describe("collectInboundChannels — v0.5.94 DM allowlist", () => {
+    it("emits DM keys as telegram:dm:<user_id> when inbound_dm_user_ids is set", () => {
+        const ch = collectInboundChannels({
+            telegram: { inbound_dm_user_ids: ["123"] },
+        });
+        expect(ch).toEqual(["telegram:dm:123"]);
+    });
+    it("supports multiple DM user_ids", () => {
+        const ch = collectInboundChannels({
+            telegram: { inbound_dm_user_ids: ["123", "456"] },
+        });
+        expect(ch).toEqual(["telegram:dm:123", "telegram:dm:456"]);
+    });
+    it("emits both group + topic + DM keys when all are configured", () => {
+        const ch = collectInboundChannels({
+            telegram: {
+                inbound_chat_ids: ["-100super"],
+                inbound_topic_ids: [15],
+                inbound_dm_user_ids: ["8075471258"],
+            },
+        });
+        expect(ch).toEqual(["telegram:-100super:15", "telegram:dm:8075471258"]);
+    });
+    it("schema backwards-compat: config without inbound_dm_user_ids still works", () => {
+        const ch = collectInboundChannels({
+            telegram: { inbound_chat_ids: ["-100"] },
+        });
+        expect(ch).toEqual(["telegram:-100"]);
+    });
+    it("empty inbound_dm_user_ids list emits no DM keys", () => {
+        const ch = collectInboundChannels({
+            telegram: { inbound_dm_user_ids: [] },
+        });
+        expect(ch).toEqual([]);
+    });
+});
+describe("buildRoutingIndex — v0.5.94 DM key indexing", () => {
+    it("indexes DM keys so worker can look up by telegram:dm:<user_id>", () => {
+        const cfgs = new Map([
+            ["uuid-dm", { telegram: { inbound_dm_user_ids: ["8075471258"] } }],
+        ]);
+        const idx = buildRoutingIndex(cfgs);
+        expect(idx.get("telegram:dm:8075471258")).toBe("uuid-dm");
+        expect(idx.size).toBe(1);
+    });
+    it("two projects can each have their own DM allowlist (no collision)", () => {
+        const cfgs = new Map([
+            ["uuid-a", { telegram: { inbound_dm_user_ids: ["111"] } }],
+            ["uuid-b", { telegram: { inbound_dm_user_ids: ["222"] } }],
+        ]);
+        const idx = buildRoutingIndex(cfgs);
+        expect(idx.get("telegram:dm:111")).toBe("uuid-a");
+        expect(idx.get("telegram:dm:222")).toBe("uuid-b");
+        expect(idx.size).toBe(2);
+    });
+    it("same DM user across two projects: collision warned, last wins (consistent with existing behavior)", () => {
+        const cfgs = new Map([
+            ["uuid-a", { telegram: { inbound_dm_user_ids: ["999"] } }],
+            ["uuid-b", { telegram: { inbound_dm_user_ids: ["999"] } }],
+        ]);
+        const warnings = [];
+        const idx = buildRoutingIndex(cfgs, (m) => warnings.push(m));
+        expect(idx.get("telegram:dm:999")).toBe("uuid-b");
+        expect(warnings.length).toBe(1);
+        expect(warnings[0]).toMatch(/collision.*telegram:dm:999/);
+    });
+    it("group + DM in same project: both keys index to same uuid", () => {
+        const cfgs = new Map([
+            [
+                "uuid-x",
+                {
+                    telegram: {
+                        inbound_chat_ids: ["-100"],
+                        inbound_topic_ids: [15],
+                        inbound_dm_user_ids: ["8075471258"],
+                    },
+                },
+            ],
+        ]);
+        const idx = buildRoutingIndex(cfgs);
+        expect(idx.get("telegram:-100:15")).toBe("uuid-x");
+        expect(idx.get("telegram:dm:8075471258")).toBe("uuid-x");
+        expect(idx.get("telegram:-100")).toBeUndefined(); // strict topic whitelist preserved
+        expect(idx.size).toBe(2);
+    });
+});
+describe("buildRoutingIndex — v0.7.2 topic-aware keys", () => {
+    it("emits topic-specific keys when inbound_topic_ids is set", () => {
+        const cfgs = new Map([
+            [
+                "uuid-a",
+                {
+                    telegram: {
+                        inbound_chat_ids: ["-1001234567890"],
+                        inbound_topic_ids: [5, 12],
+                    },
+                },
+            ],
+        ]);
+        const idx = buildRoutingIndex(cfgs);
+        expect(idx.get("telegram:-1001234567890:5")).toBe("uuid-a");
+        expect(idx.get("telegram:-1001234567890:12")).toBe("uuid-a");
+        // Chat-only key NOT registered when topic_ids are set — we want
+        // routing to be topic-strict.
+        expect(idx.get("telegram:-1001234567890")).toBeUndefined();
+    });
+    it("two projects sharing one supergroup but different topics get distinct routing", () => {
+        const cfgs = new Map([
+            ["uuid-a", { telegram: { inbound_chat_ids: ["-100common"], inbound_topic_ids: [5] } }],
+            ["uuid-b", { telegram: { inbound_chat_ids: ["-100common"], inbound_topic_ids: [10] } }],
+        ]);
+        const idx = buildRoutingIndex(cfgs);
+        expect(idx.get("telegram:-100common:5")).toBe("uuid-a");
+        expect(idx.get("telegram:-100common:10")).toBe("uuid-b");
+        expect(idx.size).toBe(2);
+    });
+    it("falls back to chat-only key when inbound_topic_ids is empty/unset (legacy v0.7.1)", () => {
+        const cfgs = new Map([["uuid-legacy", { telegram: { inbound_chat_ids: ["-100legacy"] } }]]);
+        const idx = buildRoutingIndex(cfgs);
+        expect(idx.get("telegram:-100legacy")).toBe("uuid-legacy");
+        expect(idx.size).toBe(1);
+    });
+});
+describe("buildRoutingIndex", () => {
+    it("builds a chat_id → uuid map", () => {
+        const cfgs = new Map([
+            ["uuid-a", { telegram: { inbound_chat_ids: ["100", "200"] } }],
+            ["uuid-b", { discord: { inbound_channel_ids: ["d1"] } }],
+        ]);
+        const idx = buildRoutingIndex(cfgs);
+        expect(idx.get("telegram:100")).toBe("uuid-a");
+        expect(idx.get("telegram:200")).toBe("uuid-a");
+        expect(idx.get("discord:d1")).toBe("uuid-b");
+        expect(idx.size).toBe(3);
+    });
+    it("calls onWarn on collision and lets the later project win", () => {
+        const cfgs = new Map([
+            ["uuid-a", { telegram: { inbound_chat_ids: ["100"] } }],
+            ["uuid-b", { telegram: { inbound_chat_ids: ["100"] } }],
+        ]);
+        const warnings = [];
+        const idx = buildRoutingIndex(cfgs, (m) => warnings.push(m));
+        // Map iteration order on insertion → uuid-b wins.
+        expect(idx.get("telegram:100")).toBe("uuid-b");
+        expect(warnings.length).toBe(1);
+        expect(warnings[0]).toMatch(/collision.*telegram:100/);
+    });
+});
+describe("saveProjectChatRouting", () => {
+    it("writes a routing file atomically, creating the project dir if missing", async () => {
+        const uuid = "save-test";
+        const res = await saveProjectChatRouting(uuid, { telegram: { report_channel: "telegram:abc", inbound_chat_ids: ["abc"] } }, tmpRoot);
+        expect(res.path).toBe(path.join(tmpRoot, "projects", uuid, "chat-routing.json"));
+        const back = await loadProjectChatRouting(uuid, tmpRoot);
+        expect(back?.telegram?.report_channel).toBe("telegram:abc");
+    });
+    it("overwrites an existing routing file (rename-over)", async () => {
+        const uuid = "overwrite-test";
+        await saveProjectChatRouting(uuid, { telegram: { report_channel: "telegram:v1" } }, tmpRoot);
+        await saveProjectChatRouting(uuid, { telegram: { report_channel: "telegram:v2" } }, tmpRoot);
+        const back = await loadProjectChatRouting(uuid, tmpRoot);
+        expect(back?.telegram?.report_channel).toBe("telegram:v2");
+    });
+});

package/dist/chat/daemon/rpc-client.d.ts

@@ -0,0 +1,45 @@
+/**
+ * chat-daemon RPC client (v0.7.1 Phase B).
+ *
+ * Used by the MCP server when it wants to send a chat message but
+ * doesn't want to start its own long-poll adapter (which would
+ * collide with any other MCP server holding the same bot token).
+ *
+ * Behavior:
+ *   - One short-lived connection per request — keeps the implementation
+ *     trivial and avoids reconnect/backoff logic. Performance is fine
+ *     for v0.7.1's expected traffic (a handful of agent reports per
+ *     project session).
+ *   - Returns a typed result on success.
+ *   - Throws `DaemonUnreachableError` when the socket can't be reached
+ *     so callers can fall back to in-process send.
+ *   - Throws `DaemonRpcError` on JSON-RPC error responses.
+ */
+import { type CreateTopicParams, type CreateTopicResult, type ListChannelsResult, type PingResult, type SendParams, type SendResult } from "./protocol.js";
+export declare class DaemonUnreachableError extends Error {
+    constructor(message: string);
+}
+export declare class DaemonRpcError extends Error {
+    readonly code: number;
+    constructor(message: string, code: number);
+}
+export interface RpcClientOptions {
+    dataRoot?: string;
+    /** Connect timeout in ms. Default 1500 — local socket, fast. */
+    connectTimeoutMs?: number;
+    /** Request timeout in ms (waiting for response). Default 5000. */
+    requestTimeoutMs?: number;
+}
+export declare class DaemonClient {
+    private readonly address;
+    private readonly connectTimeoutMs;
+    private readonly requestTimeoutMs;
+    constructor(opts?: RpcClientOptions);
+    ping(): Promise<PingResult>;
+    listChannels(): Promise<ListChannelsResult>;
+    send(params: SendParams): Promise<SendResult>;
+    createTopic(params: CreateTopicParams): Promise<CreateTopicResult>;
+    call<R>(method: string, params: unknown): Promise<R>;
+    private openSocket;
+}
+//# sourceMappingURL=rpc-client.d.ts.map

package/dist/chat/daemon/rpc-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc-client.d.ts","sourceRoot":"","sources":["../../../src.legacy/chat/daemon/rpc-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EAGtB,KAAK,kBAAkB,EACvB,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,UAAU,EAEhB,MAAM,eAAe,CAAC;AAEvB,qBAAa,sBAAuB,SAAQ,KAAK;gBACnC,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,cAAe,SAAQ,KAAK;IAGrC,QAAQ,CAAC,IAAI,EAAE,MAAM;gBADrB,OAAO,EAAE,MAAM,EACN,IAAI,EAAE,MAAM;CAKxB;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gEAAgE;IAChE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kEAAkE;IAClE,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAID,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;gBAE9B,IAAI,GAAE,gBAAqB;IAMvC,IAAI,IAAI,OAAO,CAAC,UAAU,CAAC;IAI3B,YAAY,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAI3C,IAAI,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAI7C,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAI5D,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC;IAiB1D,OAAO,CAAC,UAAU;CAwBnB"}