@chinchillaenterprises/mcp-claude-channel 0.1.0 → 0.3.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZWlvLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2ZpbGVpby50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxPQUFPLEVBQUUsVUFBVSxFQUFFLFFBQVEsRUFBRSxTQUFTLEVBQUUsUUFBUSxFQUFFLFFBQVEsRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBRWxHLG1EQUFtRDtBQUNuRCxNQUFNLFVBQVUsVUFBVSxDQUFDLElBQVksRUFBRSxHQUFZO0lBQ25ELE1BQU0sRUFBRSxHQUFHLFFBQVEsQ0FBQyxJQUFJLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFDL0IsSUFBSSxDQUFDO1FBQ0gsU0FBUyxDQUFDLEVBQUUsRUFBRSxJQUFJLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyxHQUFHLElBQUksQ0FBQyxDQUFDO0lBQzVDLENBQUM7WUFBUyxDQUFDO1FBQ1QsU0FBUyxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ2hCLENBQUM7QUFDSCxDQUFDO0FBRUQsMEVBQTBFO0FBQzFFLE1BQU0sVUFBVSxZQUFZLENBQUksSUFBWSxFQUFFLFFBQVc7SUFDdkQsSUFBSSxDQUFDO1FBQ0gsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLFlBQVksQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDLENBQU0sQ0FBQztJQUNyRCxDQUFDO0lBQUMsTUFBTSxDQUFDO1FBQ1AsT0FBTyxRQUFRLENBQUM7SUFDbEIsQ0FBQztBQUNILENBQUM7QUFFRCxnRkFBZ0Y7QUFDaEYsTUFBTSxVQUFVLGFBQWEsQ0FBQyxJQUFZLEVBQUUsR0FBWTtJQUN0RCxNQUFNLEVBQUUsR0FBRyxRQUFRLENBQUMsSUFBSSxFQUFFLEdBQUcsQ0FBQyxDQUFDO0lBQy9CLElBQUksQ0FBQztRQUNILFNBQVMsQ0FBQyxFQUFFLEVBQUUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxHQUFHLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDOUMsQ0FBQztZQUFTLENBQUM7UUFDVCxTQUFTLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDaEIsQ0FBQztBQUNILENBQUM7QUFFRDs7OztHQUlHO0FBQ0gsTUFBTSxPQUFPLE1BQU07SUFDVCxJQUFJLENBQVM7SUFDYixVQUFVLENBQVM7SUFDbkIsTUFBTSxDQUFTO0lBQ2YsTUFBTSxHQUFHLEVBQUUsQ0FBQztJQUVwQixZQUFZLElBQVksRUFBRSxVQUFtQjtRQUMzQyxJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQztRQUNqQixJQUFJLENBQUMsVUFBVSxHQUFHLFVBQVUsSUFBSSxHQUFHLElBQUksU0FBUyxDQUFDO1FBQ2pELElBQUksQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDO1lBQUUsU0FBUyxDQUFDLFFBQVEsQ0FBQyxJQUFJLEVBQUUsR0FBRyxDQUFDLENBQUMsQ0FBQztRQUN0RCxJQUFJLENBQUMsTUFBTSxHQUFHLFlBQVksQ0FBcUIsSUFBSSxDQUFDLFVBQVUsRUFBRSxFQUFFLE1BQU0sRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDLE1BQU0sQ0FBQztRQUN0RixtRUFBbUU7UUFDbkUsSUFBSSxDQUFDO1lBQ0gsSUFBSSxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQyxNQUFNO2dCQUFFLElBQUksQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDO1FBQ3pELENBQUM7UUFBQyxNQUFNLENBQUM7WUFDUCxJQUFJLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQztRQUNsQixDQUFDO0lBQ0gsQ0FBQztJQUVELCtFQUErRTtJQUMvRSxLQUFLLENBQUMsTUFBOEI7UUFDbEMsSUFBSSxJQUFZLENBQUM7UUFDakIsSUFBSSxDQUFDO1lBQ0gsSUFBSSxHQUFHLFFBQVEsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsSUFBSSxDQUFDO1FBQ2xDLENBQUM7UUFBQyxNQUFNLENBQUM7WUFDUCxPQUFPLENBQUMsQ0FBQztRQUNYLENBQUM7UUFDRCxJQUFJLElBQUksR0FBRyxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7WUFDdkIsSUFBSSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUM7WUFDaEIsSUFBSSxDQUFDLE1BQU0sR0FBRyxFQUFFLENBQUM7UUFDbkIsQ0FBQztRQUNELElBQUksSUFBSSxLQUFLLElBQUksQ0FBQyxNQUFNO1lBQUUsT0FBTyxDQUFDLENBQUM7UUFFbkMsTUFBTSxFQUFFLEdBQUcsUUFBUSxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsR0FBRyxDQUFDLENBQUM7UUFDcEMsSUFBSSxDQUFDO1lBQ0gsTUFBTSxHQUFHLEdBQUcsSUFBSSxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUM7WUFDL0IsTUFBTSxHQUFHLEdBQUcsTUFBTSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztZQUM5QixNQUFNLElBQUksR0FBRyxRQUFRLENBQUMsRUFBRSxFQUFFLEdBQUcsRUFBRSxDQUFDLEVBQUUsR0FBRyxFQUFFLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQztZQUNwRCxJQUFJLENBQUMsTUFBTSxJQUFJLElBQUksQ0FBQztZQUNwQixJQUFJLENBQUMsTUFBTSxJQUFJLEdBQUcsQ0FBQyxRQUFRLENBQUMsTUFBTSxFQUFFLENBQUMsRUFBRSxJQUFJLENBQUMsQ0FBQztRQUMvQyxDQUFDO2dCQUFTLENBQUM7WUFDVCxTQUFTLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDaEIsQ0FBQztRQUVELElBQUksS0FBSyxHQUFHLENBQUMsQ0FBQztRQUNkLElBQUksRUFBVSxDQUFDO1FBQ2YsT0FBTyxDQUFDLEVBQUUsR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLENBQUM7WUFDL0MsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDO1lBQ3RDLElBQUksQ0FBQyxNQUFNLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsRUFBRSxHQUFHLENBQUMsQ0FBQyxDQUFDO1lBQ3hDLElBQUksSUFBSSxDQUFDLElBQUksRUFBRSxFQUFFLENBQUM7Z0JBQ2hCLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQztnQkFDYixLQUFLLEVBQUUsQ0FBQztZQUNWLENBQUM7UUFDSCxDQUFDO1FBQ0QsSUFBSSxLQUFLLEdBQUcsQ0FBQztZQUFFLGFBQWEsQ0FBQyxJQUFJLENBQUMsVUFBVSxFQUFFLEVBQUUsTUFBTSxFQUFFLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDO1FBQ3ZFLE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQztDQUNGIn0=

package/dist/fleet-board.d.ts

@@ -0,0 +1,57 @@
+/**
+ * fleet-board.ts — lane presence registry writer (the MCP-tool side of the board).
+ *
+ * Backs the `clock_in` and `heartbeat` MCP tools. Writes the SAME rows/columns as
+ * the reference CLI `coordinator/scripts/clockin.sh`, so the CLI (human/ops
+ * interface) and these tools (lane interface) interoperate on one DB. Match the
+ * schema EXACTLY — see coordinator/notes/spec-fleet-board.md.
+ *
+ * DB: /Users/feather/Repos/fleet-board.db (override via FLEET_BOARD_DB). WAL mode so
+ * a lane can write its heartbeat while readers (board.sh) query. The first caller
+ * bootstraps the table + indexes (idempotent), so there is no separate init step.
+ *
+ * Uses Node's built-in `node:sqlite` (Node ≥ 22.5) — zero native deps, publish-safe.
+ */
+export declare const DEFAULT_BOARD_PATH = "/Users/feather/Repos/fleet-board.db";
+export declare function boardPath(): string;
+export interface ClockInArgs {
+    callsign: string;
+    project?: string;
+    repo_path?: string;
+    role?: string;
+    lead?: string;
+    session_id?: string;
+    pid?: number;
+    tab_name?: string;
+    model?: string;
+    git_branch?: string;
+    status?: string;
+    loop_armed?: number;
+    host?: string;
+    protocol_version?: string;
+    event?: string;
+    notes?: string;
+}
+export interface HeartbeatArgs {
+    callsign: string;
+    status?: string;
+    loop_armed?: number;
+    event?: string;
+    notes?: string;
+}
+export declare class FleetBoard {
+    private db;
+    constructor(path?: string);
+    /**
+     * Boot UPSERT on callsign. `booted_at` is stamped once on insert (never updated on
+     * conflict); `last_seen_at` = now on every call. Mirrors clockin.sh defaults.
+     */
+    clockIn(args: ClockInArgs, now?: number): void;
+    /**
+     * Heartbeat: bump last_seen_at + only the optional fields provided. Returns false
+     * if the callsign has no row (boot clock-in must run first).
+     */
+    heartbeat(args: HeartbeatArgs, now?: number): boolean;
+    close(): void;
+}
+//# sourceMappingURL=fleet-board.d.ts.map

package/dist/fleet-board.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fleet-board.d.ts","sourceRoot":"","sources":["../src/fleet-board.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH,eAAO,MAAM,kBAAkB,wCAAwC,CAAC;AAExE,wBAAgB,SAAS,IAAI,MAAM,CAElC;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAeD,qBAAa,UAAU;IACrB,OAAO,CAAC,EAAE,CAAe;gBAEb,IAAI,SAAc;IA+B9B;;;OAGG;IACH,OAAO,CAAC,IAAI,EAAE,WAAW,EAAE,GAAG,SAAgC,GAAG,IAAI;IAuDrE;;;OAGG;IACH,SAAS,CAAC,IAAI,EAAE,aAAa,EAAE,GAAG,SAAgC,GAAG,OAAO;IAwB5E,KAAK,IAAI,IAAI;CAOd"}

package/dist/fleet-board.js

@@ -0,0 +1,141 @@
+/**
+ * fleet-board.ts — lane presence registry writer (the MCP-tool side of the board).
+ *
+ * Backs the `clock_in` and `heartbeat` MCP tools. Writes the SAME rows/columns as
+ * the reference CLI `coordinator/scripts/clockin.sh`, so the CLI (human/ops
+ * interface) and these tools (lane interface) interoperate on one DB. Match the
+ * schema EXACTLY — see coordinator/notes/spec-fleet-board.md.
+ *
+ * DB: /Users/feather/Repos/fleet-board.db (override via FLEET_BOARD_DB). WAL mode so
+ * a lane can write its heartbeat while readers (board.sh) query. The first caller
+ * bootstraps the table + indexes (idempotent), so there is no separate init step.
+ *
+ * Uses Node's built-in `node:sqlite` (Node ≥ 22.5) — zero native deps, publish-safe.
+ */
+import { DatabaseSync } from "node:sqlite";
+import { hostname } from "os";
+import { execFileSync } from "child_process";
+export const DEFAULT_BOARD_PATH = "/Users/feather/Repos/fleet-board.db";
+export function boardPath() {
+    return process.env.FLEET_BOARD_DB || DEFAULT_BOARD_PATH;
+}
+/** Derive the git branch of a repo path (best-effort; "" if not a repo). */
+function deriveBranch(repoPath) {
+    if (!repoPath)
+        return "";
+    try {
+        return execFileSync("git", ["-C", repoPath, "rev-parse", "--abbrev-ref", "HEAD"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        return "";
+    }
+}
+export class FleetBoard {
+    db;
+    constructor(path = boardPath()) {
+        this.db = new DatabaseSync(path);
+        this.db.exec("PRAGMA journal_mode = WAL;");
+        this.db.exec("PRAGMA busy_timeout = 5000;");
+        // Schema MUST match clockin.sh exactly so CLI + MCP rows interoperate.
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS lanes (
+        callsign TEXT PRIMARY KEY,
+        session_id TEXT,
+        project TEXT,
+        repo_path TEXT,
+        role TEXT,
+        lead TEXT,
+        host TEXT,
+        pid INTEGER,
+        tab_name TEXT,
+        status TEXT DEFAULT 'alive',
+        booted_at INTEGER,
+        last_seen_at INTEGER,
+        loop_armed INTEGER,
+        model TEXT,
+        git_branch TEXT,
+        protocol_version TEXT,
+        last_event TEXT,
+        notes TEXT
+      );
+    `);
+        this.db.exec("CREATE INDEX IF NOT EXISTS idx_lanes_project_status ON lanes(project, status);");
+        this.db.exec("CREATE INDEX IF NOT EXISTS idx_lanes_last_seen ON lanes(last_seen_at);");
+    }
+    /**
+     * Boot UPSERT on callsign. `booted_at` is stamped once on insert (never updated on
+     * conflict); `last_seen_at` = now on every call. Mirrors clockin.sh defaults.
+     */
+    clockIn(args, now = Math.floor(Date.now() / 1000)) {
+        const host = args.host && args.host.trim() ? args.host : hostname();
+        const lead = args.lead && args.lead.trim() ? args.lead : "omega";
+        const status = args.status && args.status.trim() ? args.status : "alive";
+        const branch = args.git_branch && args.git_branch.trim() ? args.git_branch : deriveBranch(args.repo_path);
+        const loopArmed = args.loop_armed === 1 || args.loop_armed === true ? 1 : 0;
+        this.db
+            .prepare(`INSERT INTO lanes (
+           callsign, session_id, project, repo_path, role, lead, host, pid, tab_name,
+           status, booted_at, last_seen_at, loop_armed, model, git_branch,
+           protocol_version, last_event, notes
+         ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+         ON CONFLICT(callsign) DO UPDATE SET
+           session_id       = excluded.session_id,
+           project          = excluded.project,
+           repo_path        = excluded.repo_path,
+           role             = excluded.role,
+           lead             = excluded.lead,
+           host             = excluded.host,
+           pid              = excluded.pid,
+           tab_name         = excluded.tab_name,
+           status           = excluded.status,
+           last_seen_at     = excluded.last_seen_at,
+           loop_armed       = excluded.loop_armed,
+           model            = excluded.model,
+           git_branch       = excluded.git_branch,
+           protocol_version = excluded.protocol_version,
+           last_event       = excluded.last_event,
+           notes            = excluded.notes`)
+            .run(args.callsign, args.session_id ?? "", args.project ?? "", args.repo_path ?? "", args.role ?? "", lead, host, args.pid ?? null, args.tab_name ?? "", status, now, // booted_at (insert only — DO UPDATE omits it)
+        now, // last_seen_at
+        loopArmed, args.model ?? "", branch, args.protocol_version ?? "", args.event ?? "", args.notes ?? "");
+    }
+    /**
+     * Heartbeat: bump last_seen_at + only the optional fields provided. Returns false
+     * if the callsign has no row (boot clock-in must run first).
+     */
+    heartbeat(args, now = Math.floor(Date.now() / 1000)) {
+        const sets = ["last_seen_at = ?"];
+        const vals = [now];
+        if (args.status !== undefined && String(args.status).trim()) {
+            sets.push("status = ?");
+            vals.push(args.status);
+        }
+        if (args.loop_armed !== undefined) {
+            sets.push("loop_armed = ?");
+            vals.push(args.loop_armed === 1 || args.loop_armed === true ? 1 : 0);
+        }
+        if (args.event !== undefined && String(args.event).trim()) {
+            sets.push("last_event = ?");
+            vals.push(args.event);
+        }
+        if (args.notes !== undefined && String(args.notes).trim()) {
+            sets.push("notes = ?");
+            vals.push(args.notes);
+        }
+        vals.push(args.callsign);
+        const res = this.db.prepare(`UPDATE lanes SET ${sets.join(", ")} WHERE callsign = ?`).run(...vals);
+        return Number(res.changes) > 0;
+    }
+    close() {
+        try {
+            this.db.close();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/index.d.ts

@@ -37,6 +37,7 @@ declare class ClaudeChannelServer {
     private offset;
     private buffer;
     private pollTimer;
+    private board;
     constructor();
     /**
      * Emit a `notifications/claude/channel` push. Each `meta` key becomes an
@@ -51,6 +52,10 @@ declare class ClaudeChannelServer {
     /** Tail our own inbox file; push each newly-appended line. */
     private startInboxTailer;
     private sendToLane;
+    private mirrorToCoordinator;
+    private getBoard;
+    private clockIn;
+    private heartbeat;
     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;AA4HH,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;IAChE,OAAO,CAAC,KAAK,CAA2B;;IAqBxC;;;;;;OAMG;YACW,aAAa;IAqB3B,6EAA6E;YAC/D,eAAe;IA8B7B,8DAA8D;IAC9D,OAAO,CAAC,gBAAgB;YAsDV,UAAU;YAwCV,mBAAmB;IAwCjC,OAAO,CAAC,QAAQ;IAKhB,OAAO,CAAC,OAAO;IAwBf,OAAO,CAAC,SAAS;IAiCjB,OAAO,CAAC,aAAa;IAgHf,GAAG;CAgBV;AAkGD,OAAO,EAAE,mBAAmB,EAAE,CAAC"}