@chinchillaenterprises/mcp-claude-channel 0.1.0 → 0.2.0

package/README.md

@@ -100,6 +100,49 @@ claude --dangerously-load-development-channels server:claude-channel
 }
 ```
 
+## v0.2 — inbound Slack → lane router (the `--ingest` bridge)
+
+v0.2 adds a second run mode that brings messages **from Slack into the lanes**. It runs
+as its own resident process (`node dist/index.js --ingest`), separate from the per-lane
+stdio server above, and keeps three layers clean:
+
+1. **Transport / ingest (this package).** A pluggable **`InboundAdapter`** seam. Adapter
+   #1 is `SlackAdapter` — polls watched channels via the Slack Web API (reusing
+   `SLACK_BOT_TOKEN`, no public webhook), normalizes each new human message to a
+   transport-agnostic **envelope**, and stages it. A GitHub-issues webhook is the planned
+   adapter #2: same envelope, same staging log, same router — `envelope.source`
+   (`slack` | `github`) is the only distinguisher.
+2. **Router (Coordinator-owned policy).** Reads a hot-reloaded `routing-policy.yaml`
+   (`(channel, person) → suggested_domain + suggested_lane`) — **never hardcoded**.
+   `suggested_lane` is a free-form target id that may name a bare lane (`alpha`) or a
+   **formation seat** (`squad-alpha`). The router classifies and tags the hint only.
+3. **Delivery.** The **Coordinator (omega) is the sole receiver**: every inbound is
+   delivered to `chan-<COORDINATOR_LANE>-in.jsonl` carrying the routing hint plus the
+   **reply-back return address** (`reply_channel`, `requester`, `thread_ts`,
+   `envelope_id`) so a reply routes home even when source channel ≠ handling domain.
+
+**Pipeline:** `adapter.collect()` → staging log `chan-inbound-raw.jsonl` (the one new
+buffer, append-only JSONL, the proven side-door idiom) → router tails it from a journaled
+offset (no-loss / no-double-process) → Coordinator inbox.
+
+**Outbound mirror.** Lanes MAY reply to a Slack requester directly (low latency), but must
+call the **`mirror_to_coordinator`** tool once per reply so the Coordinator keeps the full
+conversation map. Lane owns the answer; Coordinator owns the routing picture.
+
+### Ingest configuration
+
+| Env var | Default | Notes |
+| --- | --- | --- |
+| `ROUTING_POLICY_PATH` | _(required)_ | Coordinator-owned routing-policy YAML (hot-reloaded). |
+| `SLACK_BOT_TOKEN` | _(required for `--ingest`)_ | Existing bot token; the Slack poll adapter. |
+| `LANE_INBOX_DIR` | `/tmp` | Holds the staging log, cursor bookmark, and lane inboxes. |
+| `COORDINATOR_LANE` | `omega` | Sole-receiver lane; also the `mirror_to_coordinator` target. |
+
+```bash
+ROUTING_POLICY_PATH=/path/routing-policy.yaml SLACK_BOT_TOKEN=xoxb-… \
+  LANE_INBOX_DIR=/path/inboxes node dist/index.js --ingest
+```
+
 ## Build
 
 ```bash
@@ -112,6 +155,7 @@ Published via the repo's OIDC `publish.yml`. Bump the version in **both**
 
 ## Roadmap
 
-- **v1 (this):** lane-to-lane nudges, file-inbox transport, no Slack.
-- **v2 (deferred, not deleted):** the Slack-bridge half — one app posting a remote
-  readout when the human walks away. See ChillMCP issues #8 / #13.
+- **v0.1:** lane-to-lane nudges, file-inbox transport, no Slack.
+- **v0.2 (this):** inbound Slack → lane router (`--ingest` bridge), pluggable
+  `InboundAdapter` seam, Coordinator-owned routing policy, `mirror_to_coordinator`.
+- **next:** GitHub-issues webhook as adapter #2 (same envelope / staging log / router).

package/dist/adapter.d.ts

@@ -0,0 +1,21 @@
+/**
+ * adapter.ts — the pluggable INBOUND adapter seam.
+ *
+ * An adapter's only job: produce normalized Envelopes from some source. The staging
+ * writer, the queue (chan-inbound-raw.jsonl), and the router know NOTHING about the
+ * source — they branch only on `envelope.source` if ever needed. Slack-poll is
+ * adapter #1; a GitHub-issues webhook is adapter #2 (same envelope, same staging log,
+ * same router). New sources = a new adapter, zero changes downstream.
+ *
+ * `collect()` is pull-shaped (poll adapters return their new batch each tick). A
+ * push adapter (webhook) can implement it as "drain whatever I've buffered since the
+ * last call", keeping the bridge's tick loop uniform across adapter kinds.
+ */
+import type { Envelope } from "./envelope.js";
+export interface InboundAdapter {
+    /** Source tag stamped on every envelope this adapter emits ("slack" | "github" | …). */
+    readonly source: string;
+    /** Return the batch of new normalized envelopes since the last call. */
+    collect(): Promise<Envelope[]>;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,MAAM,WAAW,cAAc;IAC7B,wFAAwF;IACxF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wEAAwE;IACxE,OAAO,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;CAChC"}

package/dist/adapter.js

@@ -0,0 +1,15 @@
+/**
+ * adapter.ts — the pluggable INBOUND adapter seam.
+ *
+ * An adapter's only job: produce normalized Envelopes from some source. The staging
+ * writer, the queue (chan-inbound-raw.jsonl), and the router know NOTHING about the
+ * source — they branch only on `envelope.source` if ever needed. Slack-poll is
+ * adapter #1; a GitHub-issues webhook is adapter #2 (same envelope, same staging log,
+ * same router). New sources = a new adapter, zero changes downstream.
+ *
+ * `collect()` is pull-shaped (poll adapters return their new batch each tick). A
+ * push adapter (webhook) can implement it as "drain whatever I've buffered since the
+ * last call", keeping the bridge's tick loop uniform across adapter kinds.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWRhcHRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9hZGFwdGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7R0FZRyJ9

package/dist/envelope.d.ts

@@ -0,0 +1,47 @@
+/**
+ * envelope.ts — the normalized inbound-message envelope (transport-agnostic).
+ *
+ * Slack is adapter #1; Teams / in-app BeonIQ plug into the same shape later. The
+ * ingest leg produces everything down to `text/ts/thread_ts`; the ROUTER fills
+ * `suggested_domain` + `suggested_lane` from Coordinator-owned policy (never
+ * hardcoded). Delivery model: the Coordinator (omega) is the SOLE receiver — every
+ * inbound goes to its inbox carrying those two fields as HINTS; omega makes the
+ * actual lane dispatch.
+ *
+ * The `channel` + `requester` + `thread_ts` + `id` fields are the REPLY-BACK
+ * return address: a lane's answer routes home to the original asker even when the
+ * source channel ≠ the handling domain (the "Tuck missing a tool" Beon→echelon case).
+ */
+export interface Party {
+    id: string;
+    name: string;
+    display: string;
+}
+export interface ChannelRef {
+    id: string;
+    name: string;
+}
+export type Domain = "beon" | "echelon" | "triage" | null;
+export interface Envelope {
+    v: 1;
+    id: string;
+    source: string;
+    channel: ChannelRef;
+    requester: Party;
+    text: string;
+    ts: string;
+    thread_ts: string | null;
+    suggested_domain: Domain;
+    suggested_lane: string | null;
+}
+export declare function makeEnvelopeId(source: string, ts: string, channelId: string): string;
+/** Build an ingest-stage envelope (domain/routed_lane left null for the router). */
+export declare function newEnvelope(params: {
+    source: string;
+    channel: ChannelRef;
+    requester: Party;
+    text: string;
+    ts: string;
+    thread_ts?: string | null;
+}): Envelope;
+//# sourceMappingURL=envelope.d.ts.map

package/dist/envelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelope.d.ts","sourceRoot":"","sources":["../src/envelope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,WAAW,KAAK;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,MAAM,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,GAAG,IAAI,CAAC;AAE1D,MAAM,WAAW,QAAQ;IACvB,CAAC,EAAE,CAAC,CAAC;IACL,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,UAAU,CAAC;IACpB,SAAS,EAAE,KAAK,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IAKzB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEpF;AAED,oFAAoF;AACpF,wBAAgB,WAAW,CAAC,MAAM,EAAE;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,UAAU,CAAC;IACpB,SAAS,EAAE,KAAK,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B,GAAG,QAAQ,CAaX"}

package/dist/envelope.js

@@ -0,0 +1,33 @@
+/**
+ * envelope.ts — the normalized inbound-message envelope (transport-agnostic).
+ *
+ * Slack is adapter #1; Teams / in-app BeonIQ plug into the same shape later. The
+ * ingest leg produces everything down to `text/ts/thread_ts`; the ROUTER fills
+ * `suggested_domain` + `suggested_lane` from Coordinator-owned policy (never
+ * hardcoded). Delivery model: the Coordinator (omega) is the SOLE receiver — every
+ * inbound goes to its inbox carrying those two fields as HINTS; omega makes the
+ * actual lane dispatch.
+ *
+ * The `channel` + `requester` + `thread_ts` + `id` fields are the REPLY-BACK
+ * return address: a lane's answer routes home to the original asker even when the
+ * source channel ≠ the handling domain (the "Tuck missing a tool" Beon→echelon case).
+ */
+export function makeEnvelopeId(source, ts, channelId) {
+    return `in-${source}-${ts}-${channelId}`;
+}
+/** Build an ingest-stage envelope (domain/routed_lane left null for the router). */
+export function newEnvelope(params) {
+    return {
+        v: 1,
+        id: makeEnvelopeId(params.source, params.ts, params.channel.id),
+        source: params.source,
+        channel: params.channel,
+        requester: params.requester,
+        text: params.text,
+        ts: params.ts,
+        thread_ts: params.thread_ts ?? null,
+        suggested_domain: null,
+        suggested_lane: null,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW52ZWxvcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvZW52ZWxvcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7R0FhRztBQWdDSCxNQUFNLFVBQVUsY0FBYyxDQUFDLE1BQWMsRUFBRSxFQUFVLEVBQUUsU0FBaUI7SUFDMUUsT0FBTyxNQUFNLE1BQU0sSUFBSSxFQUFFLElBQUksU0FBUyxFQUFFLENBQUM7QUFDM0MsQ0FBQztBQUVELG9GQUFvRjtBQUNwRixNQUFNLFVBQVUsV0FBVyxDQUFDLE1BTzNCO0lBQ0MsT0FBTztRQUNMLENBQUMsRUFBRSxDQUFDO1FBQ0osRUFBRSxFQUFFLGNBQWMsQ0FBQyxNQUFNLENBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQyxFQUFFLEVBQUUsTUFBTSxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUM7UUFDL0QsTUFBTSxFQUFFLE1BQU0sQ0FBQyxNQUFNO1FBQ3JCLE9BQU8sRUFBRSxNQUFNLENBQUMsT0FBTztRQUN2QixTQUFTLEVBQUUsTUFBTSxDQUFDLFNBQVM7UUFDM0IsSUFBSSxFQUFFLE1BQU0sQ0FBQyxJQUFJO1FBQ2pCLEVBQUUsRUFBRSxNQUFNLENBQUMsRUFBRTtRQUNiLFNBQVMsRUFBRSxNQUFNLENBQUMsU0FBUyxJQUFJLElBQUk7UUFDbkMsZ0JBQWdCLEVBQUUsSUFBSTtRQUN0QixjQUFjLEVBQUUsSUFBSTtLQUNyQixDQUFDO0FBQ0osQ0FBQyJ9

package/dist/fileio.d.ts

@@ -0,0 +1,28 @@
+/**
+ * fileio.ts — append-only JSONL helpers + a resumable line tailer.
+ *
+ * The whole bus is append-only JSONL (the proven side-door idiom). The router is
+ * "just another tailer" of chan-inbound-raw.jsonl, with an offset bookmark on disk
+ * so nothing is lost or double-processed across restarts.
+ */
+/** Atomically append one JSON record as a line. */
+export declare function appendLine(path: string, obj: unknown): void;
+/** Read a tiny JSON bookmark file; return fallback if missing/corrupt. */
+export declare function readJsonFile<T>(path: string, fallback: T): T;
+/** Write a tiny JSON bookmark file (whole-file overwrite — these are small). */
+export declare function writeJsonFile(path: string, obj: unknown): void;
+/**
+ * Tail a JSONL file from a persisted byte offset, invoking `onLine` per new line.
+ * The offset is journaled to `<path>.offset` after each batch so a restart resumes
+ * exactly where it left off (no-loss, no double-process).
+ */
+export declare class Tailer {
+    private path;
+    private offsetPath;
+    private offset;
+    private buffer;
+    constructor(path: string, offsetPath?: string);
+    /** Drain newly-appended whole lines. Returns the number of lines processed. */
+    drain(onLine: (line: string) => void): number;
+}
+//# sourceMappingURL=fileio.d.ts.map

package/dist/fileio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileio.d.ts","sourceRoot":"","sources":["../src/fileio.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,mDAAmD;AACnD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,GAAG,IAAI,CAO3D;AAED,0EAA0E;AAC1E,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC,CAM5D;AAED,gFAAgF;AAChF,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,GAAG,IAAI,CAO9D;AAED;;;;GAIG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAM;gBAER,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;IAa7C,+EAA+E;IAC/E,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM;CAqC9C"}

package/dist/fileio.js

@@ -0,0 +1,104 @@
+/**
+ * fileio.ts — append-only JSONL helpers + a resumable line tailer.
+ *
+ * The whole bus is append-only JSONL (the proven side-door idiom). The router is
+ * "just another tailer" of chan-inbound-raw.jsonl, with an offset bookmark on disk
+ * so nothing is lost or double-processed across restarts.
+ */
+import { existsSync, openSync, closeSync, statSync, readSync, writeSync, readFileSync } from "fs";
+/** Atomically append one JSON record as a line. */
+export function appendLine(path, obj) {
+    const fd = openSync(path, "a");
+    try {
+        writeSync(fd, JSON.stringify(obj) + "\n");
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/** Read a tiny JSON bookmark file; return fallback if missing/corrupt. */
+export function readJsonFile(path, fallback) {
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return fallback;
+    }
+}
+/** Write a tiny JSON bookmark file (whole-file overwrite — these are small). */
+export function writeJsonFile(path, obj) {
+    const fd = openSync(path, "w");
+    try {
+        writeSync(fd, JSON.stringify(obj, null, 2));
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/**
+ * Tail a JSONL file from a persisted byte offset, invoking `onLine` per new line.
+ * The offset is journaled to `<path>.offset` after each batch so a restart resumes
+ * exactly where it left off (no-loss, no double-process).
+ */
+export class Tailer {
+    path;
+    offsetPath;
+    offset;
+    buffer = "";
+    constructor(path, offsetPath) {
+        this.path = path;
+        this.offsetPath = offsetPath || `${path}.offset`;
+        if (!existsSync(path))
+            closeSync(openSync(path, "a"));
+        this.offset = readJsonFile(this.offsetPath, { offset: 0 }).offset;
+        // Guard against a bookmark pointing past a truncated/rotated file.
+        try {
+            if (statSync(path).size < this.offset)
+                this.offset = 0;
+        }
+        catch {
+            this.offset = 0;
+        }
+    }
+    /** Drain newly-appended whole lines. Returns the number of lines processed. */
+    drain(onLine) {
+        let size;
+        try {
+            size = statSync(this.path).size;
+        }
+        catch {
+            return 0;
+        }
+        if (size < this.offset) {
+            this.offset = 0;
+            this.buffer = "";
+        }
+        if (size === this.offset)
+            return 0;
+        const fd = openSync(this.path, "r");
+        try {
+            const len = size - this.offset;
+            const buf = Buffer.alloc(len);
+            const read = readSync(fd, buf, 0, len, this.offset);
+            this.offset += read;
+            this.buffer += buf.toString("utf8", 0, read);
+        }
+        finally {
+            closeSync(fd);
+        }
+        let count = 0;
+        let nl;
+        while ((nl = this.buffer.indexOf("\n")) !== -1) {
+            const line = this.buffer.slice(0, nl);
+            this.buffer = this.buffer.slice(nl + 1);
+            if (line.trim()) {
+                onLine(line);
+                count++;
+            }
+        }
+        if (count > 0)
+            writeJsonFile(this.offsetPath, { offset: this.offset });
+        return count;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/index.d.ts

@@ -51,6 +51,7 @@ declare class ClaudeChannelServer {
     /** Tail our own inbox file; push each newly-appended line. */
     private startInboxTailer;
     private sendToLane;
+    private mirrorToCoordinator;
     private setupHandlers;
     run(): Promise<void>;
 }

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAqEH,cAAM,mBAAmB;IACvB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAqC;IACtD,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,SAAS,CAA+C;;IAqBhE;;;;;;OAMG;YACW,aAAa;IAqB3B,6EAA6E;YAC/D,eAAe;IA8B7B,8DAA8D;IAC9D,OAAO,CAAC,gBAAgB;YAsDV,UAAU;IAwCxB,OAAO,CAAC,aAAa;IAgDf,GAAG;CAgBV;AAmBD,OAAO,EAAE,mBAAmB,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AA6FH,cAAM,mBAAmB;IACvB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAqC;IACtD,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,SAAS,CAA+C;;IAqBhE;;;;;;OAMG;YACW,aAAa;IAqB3B,6EAA6E;YAC/D,eAAe;IA8B7B,8DAA8D;IAC9D,OAAO,CAAC,gBAAgB;YAsDV,UAAU;YAwCV,mBAAmB;IAwCjC,OAAO,CAAC,aAAa;IAkEf,GAAG;CAgBV;AAkGD,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/index.js

@@ -37,7 +37,13 @@ import { z } from "zod";
 import { fileURLToPath } from "url";
 import { realpathSync, existsSync, closeSync, openSync, statSync, readSync, writeSync } from "fs";
 import { join } from "path";
-const VERSION = "0.1.0";
+import { PolicyStore } from "./policy.js";
+import { SlackClient } from "./slack.js";
+import { SlackAdapter } from "./slack-adapter.js";
+import { Ingestor } from "./ingest.js";
+import { Router } from "./router.js";
+import { appendLine } from "./fileio.js";
+const VERSION = "0.2.0";
 function inboxPathFor(dir, lane) {
     return join(dir, `chan-${lane}-in.jsonl`);
 }
@@ -50,7 +56,10 @@ function loadConfigFromEnv() {
         .split(/[,\s]+/)
         .map((s) => s.trim())
         .filter(Boolean));
-    return { lane, inboxDir, inboxPath: inboxPathFor(inboxDir, lane), allowedSenders };
+    // The Coordinator lane that owns the routing picture. Lanes mirror every outbound
+    // Slack reply here so the Coordinator keeps the full conversation map.
+    const coordinatorLane = (process.env.COORDINATOR_LANE || "omega").trim();
+    return { lane, inboxDir, inboxPath: inboxPathFor(inboxDir, lane), allowedSenders, coordinatorLane };
 }
 // ---------------------------------------------------------------------------
 // Tool schema
@@ -66,6 +75,17 @@ const SendToLaneArgsSchema = z.object({
         .optional()
         .describe("Structured routing payload: round_id, stage, baton_path, to_lane, etc. from_lane is stamped automatically."),
 });
+// Outbound mirror: when a lane replies to a Slack requester directly (low latency),
+// it MUST mirror that reply to the Coordinator so the full conversation map stays
+// complete. One call, can't be forgotten. Lane owns the answer; Coordinator owns the
+// routing picture.
+const MirrorToCoordinatorArgsSchema = z.object({
+    reply_text: z.string().min(1).describe("The reply this lane sent (or is about to send) to the Slack requester."),
+    reply_channel: z.string().min(1).describe("Slack channel id the reply went to (the requester's channel)."),
+    requester: z.string().optional().describe("Display name / handle of the original requester."),
+    envelope_id: z.string().optional().describe("The inbound envelope id this reply answers (for correlation)."),
+    meta: z.record(z.any()).optional().describe("Any extra context (thread_ts, suggested_lane, etc.)."),
+});
 // ---------------------------------------------------------------------------
 // Server
 // ---------------------------------------------------------------------------
@@ -233,6 +253,40 @@ class ClaudeChannelServer {
             };
         }
     }
+    // --- outbound mirror: copy a lane's Slack reply to the Coordinator ----------
+    async mirrorToCoordinator(args) {
+        const v = MirrorToCoordinatorArgsSchema.parse(args);
+        const targetPath = inboxPathFor(this.config.inboxDir, this.config.coordinatorLane);
+        const meta = {
+            to_lane: this.config.coordinatorLane,
+            mirror: true,
+            kind: "outbound_reply",
+            reply_channel: v.reply_channel,
+            requester: v.requester,
+            envelope_id: v.envelope_id,
+            ...(v.meta || {}),
+            from_lane: this.config.lane,
+        };
+        const content = `↩️ ${this.config.lane} replied to ${v.requester || "requester"} in ${v.reply_channel}: ` +
+            `"${v.reply_text.replace(/\s+/g, " ").trim().slice(0, 160)}"`;
+        try {
+            appendLine(targetPath, { content, meta });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ ok: true, mirrored_to: this.config.coordinatorLane, inbox: targetPath, envelope_id: v.envelope_id }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `Error mirroring to coordinator '${this.config.coordinatorLane}': ${err?.message || err}` }],
+                isError: true,
+            };
+        }
+    }
     // --- handlers ---------------------------------------------------------------
     setupHandlers() {
         this.server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -259,6 +313,21 @@ class ClaudeChannelServer {
                         required: ["target", "text"],
                     },
                 },
+                {
+                    name: "mirror_to_coordinator",
+                    description: "Mirror an outbound Slack reply to the Coordinator's inbox. Lanes MAY answer a Slack requester directly (low latency — matters for customers), but EVERY such reply MUST be mirrored here so the Coordinator keeps the full conversation map. Rule of thumb: the lane owns the answer, the Coordinator owns the routing picture. Call this once per outbound reply — it's the can't-forget-it copy.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            reply_text: { type: "string", description: "The reply this lane sent to the Slack requester." },
+                            reply_channel: { type: "string", description: "Slack channel id the reply went to." },
+                            requester: { type: "string", description: "Display name / handle of the original requester." },
+                            envelope_id: { type: "string", description: "Inbound envelope id this reply answers (for correlation)." },
+                            meta: { type: "object", description: "Extra context (thread_ts, suggested_lane, etc.)." },
+                        },
+                        required: ["reply_text", "reply_channel"],
+                    },
+                },
             ];
             return { tools };
         });
@@ -268,6 +337,8 @@ class ClaudeChannelServer {
                 switch (name) {
                     case "send_to_lane":
                         return await this.sendToLane(args);
+                    case "mirror_to_coordinator":
+                        return await this.mirrorToCoordinator(args);
                     default:
                         throw new Error(`Unknown tool: ${name}`);
                 }
@@ -294,6 +365,71 @@ class ClaudeChannelServer {
         process.once("SIGTERM", shutdown);
     }
 }
+// ---------------------------------------------------------------------------
+// Bridge mode (`--ingest`): poll Slack → staging log → router → Coordinator inbox.
+//
+// This is the inbound Slack→lane router. It runs as its OWN resident process
+// (not the per-lane MCP server above). The two legs share one tick:
+//   1. Ingestor.poll()  — pull new messages from watched channels into the staging
+//      log (chan-inbound-raw.jsonl), bookmarked per-channel for no-loss/no-replay.
+//   2. Router.drain()   — classify each staged envelope against Coordinator-owned
+//      policy and deliver to the Coordinator inbox (omega is the sole receiver).
+// Policy (watch list, suggested domain/lane, person overrides) is hot-reloaded.
+// ---------------------------------------------------------------------------
+async function runBridge() {
+    const inboxDir = process.env.LANE_INBOX_DIR || "/tmp";
+    const coordinatorLane = (process.env.COORDINATOR_LANE || "omega").trim();
+    const policyPath = process.env.ROUTING_POLICY_PATH;
+    const token = process.env.SLACK_BOT_TOKEN;
+    const rawLogPath = join(inboxDir, "chan-inbound-raw.jsonl");
+    const cursorsPath = join(inboxDir, "ingest-cursors.json");
+    if (!policyPath) {
+        console.error("[bridge] FATAL: ROUTING_POLICY_PATH is required (Coordinator-owned routing policy).");
+        process.exit(1);
+    }
+    if (!token) {
+        console.error("[bridge] FATAL: SLACK_BOT_TOKEN is required for the ingest poll leg.");
+        process.exit(1);
+    }
+    const policy = new PolicyStore(policyPath);
+    // Pluggable inbound adapters. Slack-poll is #1; a GitHub-issues webhook is the
+    // planned #2 — it would register here, emit the SAME envelope into the SAME
+    // staging log, and the writer/router never change.
+    const adapters = [
+        new SlackAdapter({ slack: new SlackClient(token), policy, cursorsPath }),
+    ];
+    const ingestor = new Ingestor({ adapters, rawLogPath });
+    const router = new Router({ policy, rawLogPath, inboxDir, coordinatorLane });
+    const intervalMs = Math.max(1, policy.current().pollIntervalSeconds) * 1000;
+    console.error(`[bridge] mcp-claude-channel v${VERSION} INGEST mode — poll ${policy.current().pollIntervalSeconds}s, ` +
+        `staging ${rawLogPath}, sole receiver '${coordinatorLane}'`);
+    let ticking = false;
+    const tick = async () => {
+        if (ticking)
+            return; // skip if a slow Slack pass overruns the interval
+        ticking = true;
+        try {
+            const staged = await ingestor.poll();
+            const delivered = router.drain();
+            if (staged || delivered)
+                console.error(`[bridge] tick: +${staged} staged, ${delivered} delivered`);
+        }
+        catch (err) {
+            console.error(`[bridge] tick error: ${err?.message || err}`);
+        }
+        finally {
+            ticking = false;
+        }
+    };
+    const timer = setInterval(tick, intervalMs);
+    void tick();
+    const shutdown = () => {
+        clearInterval(timer);
+        process.exit(0);
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+}
 // Boot guard — only run when invoked directly (mirrors mcp-slack).
 const isMain = (() => {
     const entry = process.argv[1];
@@ -308,8 +444,16 @@ const isMain = (() => {
     }
 })();
 if (isMain) {
-    const server = new ClaudeChannelServer();
-    server.run().catch(console.error);
+    if (process.argv.includes("--ingest")) {
+        runBridge().catch((err) => {
+            console.error("[bridge] fatal:", err);
+            process.exit(1);
+        });
+    }
+    else {
+        const server = new ClaudeChannelServer();
+        server.run().catch(console.error);
+    }
 }
 export { ClaudeChannelServer };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/ingest.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ingest.ts — the source-AGNOSTIC staging writer.
+ *
+ * Knows nothing about Slack, GitHub, or any source. It drives a set of pluggable
+ * InboundAdapters (each produces normalized Envelopes) and appends every envelope
+ * to the staging log `chan-inbound-raw.jsonl` — the single queue the router tails.
+ * Adding a source (GitHub webhook = adapter #2) means registering another adapter
+ * here; this writer, the staging log, and the router stay untouched.
+ */
+import type { InboundAdapter } from "./adapter.js";
+export declare class Ingestor {
+    private adapters;
+    private rawLogPath;
+    constructor(opts: {
+        adapters: InboundAdapter[];
+        rawLogPath: string;
+    });
+    /** Collect from every adapter and stage their envelopes. Returns count staged. */
+    poll(): Promise<number>;
+}
+//# sourceMappingURL=ingest.d.ts.map

package/dist/ingest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ingest.d.ts","sourceRoot":"","sources":["../src/ingest.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD,qBAAa,QAAQ;IACnB,OAAO,CAAC,QAAQ,CAAmB;IACnC,OAAO,CAAC,UAAU,CAAS;gBAEf,IAAI,EAAE;QAAE,QAAQ,EAAE,cAAc,EAAE,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE;IAKpE,kFAAkF;IAC5E,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;CAiB9B"}

package/dist/ingest.js

@@ -0,0 +1,38 @@
+/**
+ * ingest.ts — the source-AGNOSTIC staging writer.
+ *
+ * Knows nothing about Slack, GitHub, or any source. It drives a set of pluggable
+ * InboundAdapters (each produces normalized Envelopes) and appends every envelope
+ * to the staging log `chan-inbound-raw.jsonl` — the single queue the router tails.
+ * Adding a source (GitHub webhook = adapter #2) means registering another adapter
+ * here; this writer, the staging log, and the router stay untouched.
+ */
+import { appendLine } from "./fileio.js";
+export class Ingestor {
+    adapters;
+    rawLogPath;
+    constructor(opts) {
+        this.adapters = opts.adapters;
+        this.rawLogPath = opts.rawLogPath;
+    }
+    /** Collect from every adapter and stage their envelopes. Returns count staged. */
+    async poll() {
+        let staged = 0;
+        for (const adapter of this.adapters) {
+            let envelopes;
+            try {
+                envelopes = await adapter.collect();
+            }
+            catch (err) {
+                console.error(`[ingest] adapter '${adapter.source}' collect failed: ${err?.message || err}`);
+                continue;
+            }
+            for (const env of envelopes) {
+                appendLine(this.rawLogPath, env);
+                staged++;
+            }
+        }
+        return staged;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5nZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2luZ2VzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7R0FRRztBQUVILE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFHekMsTUFBTSxPQUFPLFFBQVE7SUFDWCxRQUFRLENBQW1CO0lBQzNCLFVBQVUsQ0FBUztJQUUzQixZQUFZLElBQXdEO1FBQ2xFLElBQUksQ0FBQyxRQUFRLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQztRQUM5QixJQUFJLENBQUMsVUFBVSxHQUFHLElBQUksQ0FBQyxVQUFVLENBQUM7SUFDcEMsQ0FBQztJQUVELGtGQUFrRjtJQUNsRixLQUFLLENBQUMsSUFBSTtRQUNSLElBQUksTUFBTSxHQUFHLENBQUMsQ0FBQztRQUNmLEtBQUssTUFBTSxPQUFPLElBQUksSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO1lBQ3BDLElBQUksU0FBUyxDQUFDO1lBQ2QsSUFBSSxDQUFDO2dCQUNILFNBQVMsR0FBRyxNQUFNLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUN0QyxDQUFDO1lBQUMsT0FBTyxHQUFRLEVBQUUsQ0FBQztnQkFDbEIsT0FBTyxDQUFDLEtBQUssQ0FBQyxxQkFBcUIsT0FBTyxDQUFDLE1BQU0scUJBQXFCLEdBQUcsRUFBRSxPQUFPLElBQUksR0FBRyxFQUFFLENBQUMsQ0FBQztnQkFDN0YsU0FBUztZQUNYLENBQUM7WUFDRCxLQUFLLE1BQU0sR0FBRyxJQUFJLFNBQVMsRUFBRSxDQUFDO2dCQUM1QixVQUFVLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRSxHQUFHLENBQUMsQ0FBQztnQkFDakMsTUFBTSxFQUFFLENBQUM7WUFDWCxDQUFDO1FBQ0gsQ0FBQztRQUNELE9BQU8sTUFBTSxDQUFDO0lBQ2hCLENBQUM7Q0FDRiJ9

package/dist/policy.d.ts

@@ -0,0 +1,52 @@
+/**
+ * policy.ts — reads the Coordinator-owned routing policy (YAML), hot-reloaded.
+ *
+ * BUILD RULE: this module READS policy; it never bakes channel IDs / lane names
+ * into capability code. The file is authored + owned by the Coordinator. The
+ * router calls `resolve()` per message; the loader re-reads the file when its
+ * mtime changes, so policy edits take effect without a restart.
+ */
+import type { Domain, Envelope } from "./envelope.js";
+export interface WatchEntry {
+    id: string;
+    name: string;
+    suggestedDomain: Domain;
+    suggestedLane: string;
+}
+export interface PersonOverride {
+    match_display?: string;
+    match_id?: string;
+    suggestedLane: string;
+    suggestedDomain?: Domain;
+}
+export interface Policy {
+    pollIntervalSeconds: number;
+    watch: WatchEntry[];
+    personOverrides: PersonOverride[];
+}
+export interface RouteHint {
+    suggestedDomain: Domain;
+    suggestedLane: string;
+    reason: string;
+}
+/**
+ * Hot-reloading policy holder. Re-reads the file only when its mtime changes, so
+ * `current()` is cheap to call on every poll tick and every routed message.
+ */
+export declare class PolicyStore {
+    private path;
+    private mtimeMs;
+    private policy;
+    private byChannel;
+    constructor(path: string);
+    reloadIfChanged(): boolean;
+    current(): Policy;
+    watchList(): WatchEntry[];
+    /**
+     * Compute the routing HINT for (channel, person). Person override beats channel
+     * default. This is advisory only — every message is delivered to omega, which
+     * makes the real dispatch.
+     */
+    resolve(env: Envelope): RouteHint;
+}
+//# sourceMappingURL=policy.d.ts.map

package/dist/policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../src/policy.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEtD,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,cAAc;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,MAAM;IACrB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,eAAe,EAAE,cAAc,EAAE,CAAC;CACnC;AAID,MAAM,WAAW,SAAS;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;CAChB;AAgCD;;;GAGG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,OAAO,CAAM;IACrB,OAAO,CAAC,MAAM,CAAyF;IACvG,OAAO,CAAC,SAAS,CAAiC;gBAEtC,IAAI,EAAE,MAAM;IAKxB,eAAe,IAAI,OAAO;IAwB1B,OAAO,IAAI,MAAM;IAKjB,SAAS,IAAI,UAAU,EAAE;IAIzB;;;;OAIG;IACH,OAAO,CAAC,GAAG,EAAE,QAAQ,GAAG,SAAS;CA4BlC"}

package/dist/policy.js

@@ -0,0 +1,115 @@
+/**
+ * policy.ts — reads the Coordinator-owned routing policy (YAML), hot-reloaded.
+ *
+ * BUILD RULE: this module READS policy; it never bakes channel IDs / lane names
+ * into capability code. The file is authored + owned by the Coordinator. The
+ * router calls `resolve()` per message; the loader re-reads the file when its
+ * mtime changes, so policy edits take effect without a restart.
+ */
+import { readFileSync, statSync } from "fs";
+import YAML from "yaml";
+const DEFAULT_POLL_SECONDS = 4;
+// Unknown channels / unmatched messages land with the Coordinator, who can see
+// everything and reroute. Safe default — never silently drop.
+const FALLBACK = {
+    suggestedDomain: "triage",
+    suggestedLane: "omega",
+};
+function parse(raw) {
+    const doc = (YAML.parse(raw) || {});
+    const watch = Array.isArray(doc.watch)
+        ? doc.watch.map((w) => ({
+            id: String(w.id),
+            name: String(w.name ?? ""),
+            suggestedDomain: (w.suggested_domain ?? null),
+            suggestedLane: String(w.suggested_lane),
+        }))
+        : [];
+    const personOverrides = Array.isArray(doc.person_overrides)
+        ? doc.person_overrides.map((p) => ({
+            match_display: p.match_display ? String(p.match_display).toLowerCase() : undefined,
+            match_id: p.match_id ? String(p.match_id) : undefined,
+            suggestedLane: String(p.suggested_lane),
+            suggestedDomain: (p.suggested_domain ?? undefined),
+        }))
+        : [];
+    const pollIntervalSeconds = Number(doc?.poll?.interval_seconds) || DEFAULT_POLL_SECONDS;
+    return { pollIntervalSeconds, watch, personOverrides };
+}
+/**
+ * Hot-reloading policy holder. Re-reads the file only when its mtime changes, so
+ * `current()` is cheap to call on every poll tick and every routed message.
+ */
+export class PolicyStore {
+    path;
+    mtimeMs = -1;
+    policy = { pollIntervalSeconds: DEFAULT_POLL_SECONDS, watch: [], personOverrides: [] };
+    byChannel = new Map();
+    constructor(path) {
+        this.path = path;
+        this.reloadIfChanged();
+    }
+    reloadIfChanged() {
+        let mtimeMs;
+        try {
+            mtimeMs = statSync(this.path).mtimeMs;
+        }
+        catch {
+            return false; // file missing — keep whatever we last had
+        }
+        if (mtimeMs === this.mtimeMs)
+            return false;
+        try {
+            const raw = readFileSync(this.path, "utf8");
+            this.policy = parse(raw);
+            this.byChannel = new Map(this.policy.watch.map((w) => [w.id, w]));
+            this.mtimeMs = mtimeMs;
+            console.error(`[policy] loaded ${this.policy.watch.length} watched channels, ` +
+                `${this.policy.personOverrides.length} person overrides from ${this.path}`);
+            return true;
+        }
+        catch (err) {
+            console.error(`[policy] reload failed (keeping previous): ${err?.message || err}`);
+            return false;
+        }
+    }
+    current() {
+        this.reloadIfChanged();
+        return this.policy;
+    }
+    watchList() {
+        return this.current().watch;
+    }
+    /**
+     * Compute the routing HINT for (channel, person). Person override beats channel
+     * default. This is advisory only — every message is delivered to omega, which
+     * makes the real dispatch.
+     */
+    resolve(env) {
+        this.reloadIfChanged();
+        const channelEntry = this.byChannel.get(env.channel.id);
+        const display = (env.requester.display || env.requester.name || "").toLowerCase();
+        for (const ov of this.policy.personOverrides) {
+            const matchByDisplay = ov.match_display && display === ov.match_display;
+            const matchById = ov.match_id && env.requester.id === ov.match_id;
+            if (matchByDisplay || matchById) {
+                // Override sets the suggested lane; domain stays the channel default unless
+                // the override pins one (source channel ≠ handling domain stays visible).
+                return {
+                    suggestedLane: ov.suggestedLane,
+                    suggestedDomain: ov.suggestedDomain ?? channelEntry?.suggestedDomain ?? FALLBACK.suggestedDomain,
+                    reason: `person_override(${ov.match_display || ov.match_id})`,
+                };
+            }
+        }
+        if (channelEntry) {
+            return {
+                suggestedLane: channelEntry.suggestedLane,
+                suggestedDomain: channelEntry.suggestedDomain,
+                reason: `channel(${channelEntry.name})`,
+            };
+        }
+        return { ...FALLBACK, reason: "fallback(unknown-channel)" };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/router.d.ts

@@ -0,0 +1,34 @@
+/**
+ * router.ts — the classification + delivery leg.
+ *
+ * "Just another tailer": reads new envelopes from the staging log
+ * `chan-inbound-raw.jsonl` (resuming from a persisted offset), stamps the routing
+ * HINT (suggested_domain / suggested_lane) from Coordinator-owned policy, and
+ * delivers EVERY message to the Coordinator's inbox (chan-omega-in.jsonl).
+ *
+ * Delivery model (Abel, 2026-06-16): the Coordinator (omega) is the SOLE receiver.
+ * The router never auto-delivers to beon/alpha — it suggests; omega dispatches.
+ * Lane-liveness alerting is the Coordinator's job, deliberately NOT built here.
+ *
+ * The inbox line stays a LEAN doorbell (nudge-not-payload): a short summary plus a
+ * meta block carrying the reply-back return address + hints + envelope_id. The full
+ * envelope persists in the staging log, keyed by id.
+ */
+import type { PolicyStore } from "./policy.js";
+export declare class Router {
+    private policy;
+    private rawLogPath;
+    private inboxDir;
+    private coordinatorLane;
+    private tailer;
+    constructor(opts: {
+        policy: PolicyStore;
+        rawLogPath: string;
+        inboxDir: string;
+        coordinatorLane: string;
+    });
+    private deliver;
+    /** Drain newly-staged envelopes, classify + deliver each to the Coordinator. */
+    drain(): number;
+}
+//# sourceMappingURL=router.d.ts.map

package/dist/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAO/C,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,MAAM,CAAS;gBAEX,IAAI,EAAE;QAAE,MAAM,EAAE,WAAW,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,eAAe,EAAE,MAAM,CAAA;KAAE;IAQxG,OAAO,CAAC,OAAO;IAmCf,gFAAgF;IAChF,KAAK,IAAI,MAAM;CAgBhB"}

package/dist/router.js

@@ -0,0 +1,86 @@
+/**
+ * router.ts — the classification + delivery leg.
+ *
+ * "Just another tailer": reads new envelopes from the staging log
+ * `chan-inbound-raw.jsonl` (resuming from a persisted offset), stamps the routing
+ * HINT (suggested_domain / suggested_lane) from Coordinator-owned policy, and
+ * delivers EVERY message to the Coordinator's inbox (chan-omega-in.jsonl).
+ *
+ * Delivery model (Abel, 2026-06-16): the Coordinator (omega) is the SOLE receiver.
+ * The router never auto-delivers to beon/alpha — it suggests; omega dispatches.
+ * Lane-liveness alerting is the Coordinator's job, deliberately NOT built here.
+ *
+ * The inbox line stays a LEAN doorbell (nudge-not-payload): a short summary plus a
+ * meta block carrying the reply-back return address + hints + envelope_id. The full
+ * envelope persists in the staging log, keyed by id.
+ */
+import { join } from "path";
+import { appendLine, Tailer } from "./fileio.js";
+function truncate(s, n = 140) {
+    const oneLine = s.replace(/\s+/g, " ").trim();
+    return oneLine.length > n ? oneLine.slice(0, n - 1) + "…" : oneLine;
+}
+export class Router {
+    policy;
+    rawLogPath;
+    inboxDir;
+    coordinatorLane;
+    tailer;
+    constructor(opts) {
+        this.policy = opts.policy;
+        this.rawLogPath = opts.rawLogPath;
+        this.inboxDir = opts.inboxDir;
+        this.coordinatorLane = opts.coordinatorLane;
+        this.tailer = new Tailer(this.rawLogPath);
+    }
+    deliver(env) {
+        const hint = this.policy.resolve(env);
+        env.suggested_domain = hint.suggestedDomain;
+        env.suggested_lane = hint.suggestedLane;
+        const inboxPath = join(this.inboxDir, `chan-${this.coordinatorLane}-in.jsonl`);
+        const doorbell = `📨 Slack inbound from ${env.requester.display} in #${env.channel.name} — ` +
+            `"${truncate(env.text)}"  [hint: ${hint.suggestedDomain}/${hint.suggestedLane}]`;
+        const line = {
+            content: doorbell,
+            meta: {
+                from_lane: "router",
+                source: env.source,
+                envelope_id: env.id,
+                // reply-back return address (source channel ≠ handling domain stays routable)
+                reply_channel: env.channel.id,
+                reply_channel_name: env.channel.name,
+                reply_thread_ts: env.thread_ts,
+                requester: env.requester.display,
+                requester_id: env.requester.id,
+                // routing HINTS — omega makes the actual dispatch
+                suggested_domain: hint.suggestedDomain,
+                suggested_lane: hint.suggestedLane,
+                route_reason: hint.reason,
+                raw_log: this.rawLogPath,
+            },
+        };
+        appendLine(inboxPath, line);
+        console.error(`[router] ${env.id} from ${env.requester.display}@#${env.channel.name} ` +
+            `→ ${this.coordinatorLane} inbox (hint ${hint.suggestedDomain}/${hint.suggestedLane}, ${hint.reason})`);
+    }
+    /** Drain newly-staged envelopes, classify + deliver each to the Coordinator. */
+    drain() {
+        return this.tailer.drain((line) => {
+            let env;
+            try {
+                env = JSON.parse(line);
+            }
+            catch {
+                console.error(`[router] skipping malformed staging line: ${truncate(line, 80)}`);
+                return;
+            }
+            try {
+                this.deliver(env);
+            }
+            catch (err) {
+                console.error(`[router] deliver failed for ${env?.id}: ${err?.message || err}`);
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/slack-adapter.d.ts

@@ -0,0 +1,29 @@
+/**
+ * slack-adapter.ts — INBOUND adapter #1: Slack poll.
+ *
+ * Implements InboundAdapter by polling each watched channel (Coordinator-owned
+ * policy) via the Slack Web API with the existing bot token — NO public webhook.
+ * Per-channel cursor bookmarks make the poll no-loss / no-replay across restarts.
+ * Cursors are a Slack-specific concern and live HERE, not in the source-agnostic
+ * staging writer. Webhook adapters won't need them.
+ */
+import type { Envelope } from "./envelope.js";
+import type { InboundAdapter } from "./adapter.js";
+import type { SlackClient } from "./slack.js";
+import type { PolicyStore } from "./policy.js";
+export declare class SlackAdapter implements InboundAdapter {
+    readonly source = "slack";
+    private slack;
+    private policy;
+    private cursorsPath;
+    private cursors;
+    private nowSeconds;
+    constructor(opts: {
+        slack: SlackClient;
+        policy: PolicyStore;
+        cursorsPath: string;
+        nowSeconds?: () => number;
+    });
+    collect(): Promise<Envelope[]>;
+}
+//# sourceMappingURL=slack-adapter.d.ts.map

package/dist/slack-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack-adapter.d.ts","sourceRoot":"","sources":["../src/slack-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,KAAK,EAAE,WAAW,EAAgB,MAAM,YAAY,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAa/C,qBAAa,YAAa,YAAW,cAAc;IACjD,QAAQ,CAAC,MAAM,WAAW;IAC1B,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,UAAU,CAAe;gBAErB,IAAI,EAAE;QAChB,KAAK,EAAE,WAAW,CAAC;QACnB,MAAM,EAAE,WAAW,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,CAAC,EAAE,MAAM,MAAM,CAAC;KAC3B;IAQK,OAAO,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;CAqCrC"}

package/dist/slack-adapter.js

@@ -0,0 +1,78 @@
+/**
+ * slack-adapter.ts — INBOUND adapter #1: Slack poll.
+ *
+ * Implements InboundAdapter by polling each watched channel (Coordinator-owned
+ * policy) via the Slack Web API with the existing bot token — NO public webhook.
+ * Per-channel cursor bookmarks make the poll no-loss / no-replay across restarts.
+ * Cursors are a Slack-specific concern and live HERE, not in the source-agnostic
+ * staging writer. Webhook adapters won't need them.
+ */
+import { readJsonFile, writeJsonFile } from "./fileio.js";
+import { newEnvelope } from "./envelope.js";
+/** Messages we never route: bot posts, joins/leaves, edits, and other subtypes. */
+function isHumanMessage(m) {
+    if (m.bot_id)
+        return false;
+    if (!m.user)
+        return false;
+    if (m.subtype)
+        return false; // channel_join, message_changed, etc.
+    if (!m.text || !m.text.trim())
+        return false;
+    return true;
+}
+export class SlackAdapter {
+    source = "slack";
+    slack;
+    policy;
+    cursorsPath;
+    cursors;
+    nowSeconds;
+    constructor(opts) {
+        this.slack = opts.slack;
+        this.policy = opts.policy;
+        this.cursorsPath = opts.cursorsPath;
+        this.cursors = readJsonFile(this.cursorsPath, {});
+        this.nowSeconds = opts.nowSeconds ?? (() => Date.now() / 1000);
+    }
+    async collect() {
+        const watch = this.policy.watchList();
+        const out = [];
+        for (const ch of watch) {
+            // Cold start: bookmark "now" so we don't replay channel history on first boot.
+            if (!this.cursors[ch.id]) {
+                this.cursors[ch.id] = String(this.nowSeconds());
+                continue;
+            }
+            let msgs;
+            try {
+                msgs = await this.slack.fetchSince(ch.id, this.cursors[ch.id]);
+            }
+            catch (err) {
+                console.error(`[slack-adapter] ${ch.name} (${ch.id}) fetch failed: ${err?.message || err}`);
+                continue;
+            }
+            let maxTs = this.cursors[ch.id];
+            for (const m of msgs) {
+                if (Number(m.ts) > Number(maxTs))
+                    maxTs = m.ts;
+                if (!isHumanMessage(m))
+                    continue;
+                const profile = await this.slack.userProfile(m.user);
+                out.push(newEnvelope({
+                    source: this.source,
+                    channel: { id: ch.id, name: ch.name },
+                    requester: profile,
+                    text: m.text || "",
+                    ts: m.ts,
+                    thread_ts: m.thread_ts ?? null,
+                }));
+            }
+            this.cursors[ch.id] = maxTs;
+        }
+        if (watch.length > 0)
+            writeJsonFile(this.cursorsPath, this.cursors);
+        return out;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/slack.d.ts

@@ -0,0 +1,38 @@
+/**
+ * slack.ts — minimal Slack Web API client for the INGEST leg.
+ *
+ * Reuses the existing Slack bot token (SLACK_BOT_TOKEN), the same credential
+ * mcp-slack already loads — no new auth, no public webhook endpoint. Just enough
+ * surface to poll new messages and resolve display names for person-overrides.
+ */
+export interface SlackMessage {
+    type?: string;
+    subtype?: string;
+    user?: string;
+    bot_id?: string;
+    text?: string;
+    ts: string;
+    thread_ts?: string;
+}
+interface UserProfile {
+    id: string;
+    name: string;
+    display: string;
+}
+export declare class SlackClient {
+    private token;
+    private base;
+    private userCache;
+    constructor(token: string);
+    private call;
+    /**
+     * Fetch messages newer than `oldestTs` (exclusive) for a channel, oldest-first.
+     * `oldestTs` is the ingest cursor bookmark; "0" means "from now-ish" on cold start
+     * (caller decides cold-start policy).
+     */
+    fetchSince(channelId: string, oldestTs: string, limit?: number): Promise<SlackMessage[]>;
+    /** Resolve a user id → profile (cached). Best-effort; never throws to the caller. */
+    userProfile(userId: string): Promise<UserProfile>;
+}
+export {};
+//# sourceMappingURL=slack.d.ts.map

package/dist/slack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack.d.ts","sourceRoot":"","sources":["../src/slack.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,UAAU,WAAW;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,IAAI,CAA2B;IACvC,OAAO,CAAC,SAAS,CAAkC;gBAEvC,KAAK,EAAE,MAAM;YAIX,IAAI;IAQlB;;;;OAIG;IACG,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAY1F,qFAAqF;IAC/E,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;CAgBxD"}

package/dist/slack.js

@@ -0,0 +1,59 @@
+/**
+ * slack.ts — minimal Slack Web API client for the INGEST leg.
+ *
+ * Reuses the existing Slack bot token (SLACK_BOT_TOKEN), the same credential
+ * mcp-slack already loads — no new auth, no public webhook endpoint. Just enough
+ * surface to poll new messages and resolve display names for person-overrides.
+ */
+export class SlackClient {
+    token;
+    base = "https://slack.com/api";
+    userCache = new Map();
+    constructor(token) {
+        this.token = token;
+    }
+    async call(method, params) {
+        const url = `${this.base}/${method}?${new URLSearchParams(params).toString()}`;
+        const res = await fetch(url, { headers: { Authorization: `Bearer ${this.token}` } });
+        const json = await res.json();
+        if (!json.ok)
+            throw new Error(`slack ${method} failed: ${json.error || "unknown"}`);
+        return json;
+    }
+    /**
+     * Fetch messages newer than `oldestTs` (exclusive) for a channel, oldest-first.
+     * `oldestTs` is the ingest cursor bookmark; "0" means "from now-ish" on cold start
+     * (caller decides cold-start policy).
+     */
+    async fetchSince(channelId, oldestTs, limit = 50) {
+        const json = await this.call("conversations.history", {
+            channel: channelId,
+            oldest: oldestTs,
+            inclusive: "false",
+            limit: String(limit),
+        });
+        const msgs = Array.isArray(json.messages) ? json.messages : [];
+        // Slack returns newest-first; we want oldest-first FIFO into the staging log.
+        return msgs.slice().sort((a, b) => Number(a.ts) - Number(b.ts));
+    }
+    /** Resolve a user id → profile (cached). Best-effort; never throws to the caller. */
+    async userProfile(userId) {
+        const cached = this.userCache.get(userId);
+        if (cached)
+            return cached;
+        let profile = { id: userId, name: userId, display: userId };
+        try {
+            const json = await this.call("users.info", { user: userId });
+            const u = json.user || {};
+            const p = u.profile || {};
+            const display = p.display_name || p.real_name || u.name || userId;
+            profile = { id: userId, name: u.name || userId, display };
+        }
+        catch (err) {
+            console.error(`[slack] users.info(${userId}) failed: ${err?.message || err}`);
+        }
+        this.userCache.set(userId, profile);
+        return profile;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@chinchillaenterprises/mcp-claude-channel",
-  "version": "0.1.0",
-  "description": "Lane-to-lane Claude Code side-door channel server. Pushes a NUDGE from a peer lane INTO a live Claude Code session via the official Channels notification (notifications/claude/channel) and exposes a send_to_lane tool to nudge the next lane. v1: session↔session only, no Slack. The SQLite Lane Board stays the source of truth; the push is a doorbell, not the payload.",
+  "version": "0.2.0",
+  "description": "Claude Code side-door channel server + inbound Slack→lane router. Lane↔lane: pushes a NUDGE into a live session via the official Channels notification (notifications/claude/channel) and a send_to_lane tool. v0.2 adds an --ingest bridge that polls Slack, normalizes to an envelope, classifies against Coordinator-owned policy, and delivers to the Coordinator inbox (sole receiver), plus a mirror_to_coordinator tool. Transport stays policy-free; the routing table is read, never hardcoded.",
   "main": "dist/index.js",
   "type": "module",
   "bin": {
@@ -31,6 +31,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.3",
+    "yaml": "^2.9.0",
     "zod": "^3.25.64"
   },
   "devDependencies": {