@nopeek/agent-bridge 0.7.25 → 0.8.1

package/dist/backends.d.ts

@@ -22,6 +22,17 @@ export declare function cpuTimeSeconds(pid: number | undefined): number | null;
  * byte-for-byte identical to tools/agent/bot-brain.sh so existing sessions
  * keep their history when a bot moves from the shell brain to the native one.
  */
+/**
+ * Where Claude Code keeps a session for a given cwd: ~/.claude/projects with
+ * every "/" and "." in the path turned into "-", then <session-uuid>.jsonl.
+ *
+ * Used only to answer "is there history here?" before deciding whether a failed
+ * --resume may be retried as a fresh --session-id. Errors read as "no session",
+ * which is the conservative answer for a NEW chat and merely costs a retry for
+ * an existing one.
+ */
+export declare function claudeSessionFile(runDir: string, sid: string): string;
+export declare function sessionExists(runDir: string, sid: string): boolean;
 export declare function sessionUuid(handle: string, channelId: string): string;
 /**
  * Claude Code backend: `claude -p` headless (reliable — no OAuth flakiness),

package/dist/backends.js

@@ -15,7 +15,7 @@ import { spawn, spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, symlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { basename, join } from "node:path";
+import { basename, join, resolve as resolvePath } from "node:path";
 import { asHooks, stripAnsi } from "./brain.js";
 import { hermesHttpBrain, probeHermesApi } from "./hermes-http.js";
 import { parseHermesActivityLine } from "./tool-progress.js";
@@ -119,6 +119,27 @@ export function cpuTimeSeconds(pid) {
  * byte-for-byte identical to tools/agent/bot-brain.sh so existing sessions
  * keep their history when a bot moves from the shell brain to the native one.
  */
+/**
+ * Where Claude Code keeps a session for a given cwd: ~/.claude/projects with
+ * every "/" and "." in the path turned into "-", then <session-uuid>.jsonl.
+ *
+ * Used only to answer "is there history here?" before deciding whether a failed
+ * --resume may be retried as a fresh --session-id. Errors read as "no session",
+ * which is the conservative answer for a NEW chat and merely costs a retry for
+ * an existing one.
+ */
+export function claudeSessionFile(runDir, sid) {
+    const slug = resolvePath(runDir).replace(/[/.]/g, "-");
+    return join(homedir(), ".claude", "projects", slug, `${sid}.jsonl`);
+}
+export function sessionExists(runDir, sid) {
+    try {
+        return existsSync(claudeSessionFile(runDir, sid));
+    }
+    catch {
+        return false;
+    }
+}
 export function sessionUuid(handle, channelId) {
     const h = createHash("sha1").update(`nopeek:${handle}:${channelId}`).digest("hex").slice(0, 32);
     return `${h.slice(0, 8)}-${h.slice(8, 12)}-5${h.slice(13, 16)}-8${h.slice(17, 20)}-${h.slice(20, 32)}`;
@@ -240,6 +261,19 @@ export function claudeBrain(cfg) {
         catch {
             /* missing/unreadable soul — run with base behavior */
         }
+        // Read and Grep are ALLOWED for this brain (only Bash/Edit/Write/Task/
+        // WebFetch are denied), so pointing at the transcript costs no new powers
+        // and is the difference between "I lost the context" and looking it up.
+        if (ctx.transcriptFile) {
+            soul +=
+                `\n\n## Recovering something you no longer remember\n\n` +
+                    `The full transcript of THIS chat is at \`${ctx.transcriptFile}\` — every message, ` +
+                    `oldest first, as \`[seq] speaker: text\`. It is rewritten before every turn and is ` +
+                    `the durable record; your own session memory is not, it gets compacted.\n\n` +
+                    `If you are missing a detail — an id, a number, what was decided — **Grep or Read ` +
+                    `that file instead of telling the user you lost context**. Saying "the context ` +
+                    `rolled" when the answer is one Grep away is not acceptable.\n`;
+        }
         const sid = sessionUuid(handle, ctx.channelId);
         const runDir = join(cfg.homeDir, "agent-run");
         mkdirSync(runDir, { recursive: true });
@@ -272,7 +306,17 @@ export function claudeBrain(cfg) {
             // into a duplicate answer; tell the user honestly.
             return BRAIN_UNREACHABLE;
         }
-        console.error(`${tag} --resume ${sid} yielded nothing (exit ${first.exitCode}) — retrying with --session-id`);
+        // --session-id on an id that ALREADY has history starts an empty
+        // conversation under that id: it does not resume, it replaces. Falling
+        // through to it on any failure is how one timeout silently threw away a
+        // chat's entire memory, with nothing but a line on the bridge's stderr to
+        // show for it. Only do it when there is genuinely nothing to lose.
+        if (sessionExists(runDir, sid)) {
+            console.error(`${tag} --resume ${sid} failed (exit ${first.exitCode}) but that session EXISTS — ` +
+                `refusing to reset it. The next message retries the resume.`);
+            return BRAIN_UNREACHABLE;
+        }
+        console.error(`${tag} no session for ${sid} yet — starting one with --session-id`);
         const second = await runClaudeOnce(bin, [...baseArgs, "--session-id", sid], text, runDir, cfg.brainTimeoutMs, tag, emit);
         if (second.reply)
             return second.reply;

package/dist/bot.d.ts

@@ -12,6 +12,11 @@ export interface BotInfo {
     /** runtime/bots serializes via Views.bot, which names the field brainBackend. */
     brainBackend?: BrainBackend | null;
 }
+/** A say() failure a caller can act on, rather than a generic 500. */
+export declare class SayError extends Error {
+    readonly code: "NOT_CONNECTED" | "NO_SUCH_CHANNEL" | "AMBIGUOUS_CHANNEL" | "NO_SUCH_BOT";
+    constructor(code: "NOT_CONNECTED" | "NO_SUCH_CHANNEL" | "AMBIGUOUS_CHANNEL" | "NO_SUCH_BOT", message: string);
+}
 export declare class BotRunner {
     readonly info: BotInfo;
     connected: boolean;
@@ -50,6 +55,36 @@ export declare class BotRunner {
     get lastForcedRestartAt(): number | null;
     /** Most recent brain turn for this bot (shared last-turn store). */
     lastTurn(): BrainTurn | null;
+    /**
+     * PROACTIVE SEND — post into a channel nobody asked us to post in.
+     *
+     * Every other path in this runner is a REPLY: a frame arrives, the brain
+     * runs, an answer goes back on that frame's channel. Monitoring inverts
+     * that. An alarm fires at 03:00 and no one has messaged the bot, so there
+     * is no inbound frame to hang a reply on and no channel implied by one.
+     * This is the only entry point that starts a conversation.
+     *
+     * `target` is a channelId OR a channel NAME (case-insensitive), resolved
+     * against the channels this bot is actually a member of. Names are the
+     * whole point: an ops script should name "xhd-alerts" and keep working if
+     * that channel is ever recreated, rather than carry an id that silently
+     * goes stale and starts posting nowhere.
+     *
+     * ensureKey() first. A bot added to a group while it was offline holds no
+     * MLS key for that group yet and send() would throw. The reply path gets
+     * this for free — an inbound frame is itself proof the key exists — but a
+     * proactive send has no such proof.
+     */
+    say(target: string, text: string): Promise<{
+        channelId: string;
+        channelName: string;
+        messageId: string;
+    }>;
+    /** The channels this bot can say() into — the address book, and the error
+     *  message when a caller names one that isn't there. */
+    listChannels(): Promise<Array<Record<string, unknown>>>;
+    private requireClient;
+    private resolveChannel;
     /**
      * Watchdog hard restart: tear the SDK client down completely and rebuild it
      * from scratch (fresh session mint + NoPeek.connect) — the proven-working

package/dist/bot.js

@@ -9,6 +9,7 @@ import { beginTurn, finishTurn, lastTurnFor } from "./last-turn.js";
 import { FileStore } from "./storage.js";
 import { TurnPublisher } from "./tool-progress.js";
 import { ChannelTurn, coalesceFollowups, isBotEcho, isPlaceholderText, isStopRequest, wrapInterruptedFollowup, wrapUserTurn, } from "./mid-turn.js";
+import { buildChatMemory, EMPTY_MEMORY } from "./chat-memory.js";
 import { buildInboundPrompt, describeStructured, hasInboundWork, isControlType, parseAttachments, saveInboundFiles, } from "./inbound-files.js";
 import { deliverOutbound, extractMedia, attachMediaFiles, stripMediaTags } from "./outbound-media.js";
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -19,6 +20,15 @@ const OWNER_PRESENCE_TTL_MS = 60_000;
 // Refresh the bot session 5 min before it expires (clamped to a sane window).
 const REFRESH_MARGIN_MS = 5 * 60_000;
 const MAX_REFRESH_DELAY_MS = 6 * 24 * 60 * 60_000;
+/** A say() failure a caller can act on, rather than a generic 500. */
+export class SayError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "SayError";
+    }
+}
 export class BotRunner {
     info;
     connected = false;
@@ -106,6 +116,82 @@ export class BotRunner {
     lastTurn() {
         return lastTurnFor(this.info.handle);
     }
+    /**
+     * PROACTIVE SEND — post into a channel nobody asked us to post in.
+     *
+     * Every other path in this runner is a REPLY: a frame arrives, the brain
+     * runs, an answer goes back on that frame's channel. Monitoring inverts
+     * that. An alarm fires at 03:00 and no one has messaged the bot, so there
+     * is no inbound frame to hang a reply on and no channel implied by one.
+     * This is the only entry point that starts a conversation.
+     *
+     * `target` is a channelId OR a channel NAME (case-insensitive), resolved
+     * against the channels this bot is actually a member of. Names are the
+     * whole point: an ops script should name "xhd-alerts" and keep working if
+     * that channel is ever recreated, rather than carry an id that silently
+     * goes stale and starts posting nowhere.
+     *
+     * ensureKey() first. A bot added to a group while it was offline holds no
+     * MLS key for that group yet and send() would throw. The reply path gets
+     * this for free — an inbound frame is itself proof the key exists — but a
+     * proactive send has no such proof.
+     */
+    async say(target, text) {
+        const ch = await this.resolveChannel(target);
+        await ch.ensureKey();
+        const sent = await ch.send({ text });
+        this.log(`say -> ${ch.record.name || ch.record.channelId} (${text.length} chars)`);
+        return { channelId: ch.record.channelId, channelName: ch.record.name, messageId: sent.messageId };
+    }
+    /** The channels this bot can say() into — the address book, and the error
+     *  message when a caller names one that isn't there. */
+    async listChannels() {
+        const chans = await this.requireClient().channels.list();
+        return chans.map((c) => ({
+            channelId: c.record.channelId,
+            name: c.record.name,
+            kind: c.record.kind,
+            e2ee: c.record.e2ee,
+            memberCount: c.record.memberCount,
+        }));
+    }
+    requireClient() {
+        if (!this.np || !this.connected) {
+            throw new SayError("NOT_CONNECTED", `bot ${this.info.handle} is not connected right now`);
+        }
+        return this.np;
+    }
+    async resolveChannel(target) {
+        const np = this.requireClient();
+        const chans = await np.channels.list();
+        const byId = chans.find((c) => c.record.channelId === target);
+        if (byId)
+            return byId;
+        const want = target.trim().toLowerCase();
+        // RESERVED TARGET "owner" — the bot's direct chat with its owner. Direct
+        // channels carry no name, so without this every caller would have to
+        // hardcode a channelId, which is the thing that rots. An ops script says
+        // "owner" and keeps working across a re-pair.
+        if (want === "owner" || want === "dm" || want === "direct") {
+            const dms = chans.filter((c) => c.record.kind === "direct" || c.record.kind === "dm");
+            if (dms.length === 1)
+                return dms[0];
+            if (dms.length > 1) {
+                throw new SayError("AMBIGUOUS_CHANNEL", `bot ${this.info.handle} has ${dms.length} direct chats - pass a channelId`);
+            }
+            throw new SayError("NO_SUCH_CHANNEL", `bot ${this.info.handle} has no direct chat yet - message it once from the app first`);
+        }
+        const byName = chans.filter((c) => (c.record.name ?? "").trim().toLowerCase() === want);
+        if (byName.length === 1)
+            return byName[0];
+        // Two channels with one name must FAIL, never pick. An alert delivered to
+        // the wrong group reads as "no alert" in the right one.
+        if (byName.length > 1) {
+            throw new SayError("AMBIGUOUS_CHANNEL", `${byName.length} channels are named "${target}" - pass a channelId instead`);
+        }
+        const known = chans.map((c) => c.record.name).filter(Boolean).join(", ") || "(none)";
+        throw new SayError("NO_SUCH_CHANNEL", `bot ${this.info.handle} is not in a channel named "${target}". It is in: ${known}`);
+    }
     /**
      * Watchdog hard restart: tear the SDK client down completely and rebuild it
      * from scratch (fresh session mint + NoPeek.connect) — the proven-working
@@ -737,7 +823,17 @@ export class BotRunner {
             published.markStarted();
             const live = new ChannelTurn();
             this.turns.set(channelId, live);
-            const prompt = interrupted ? wrapInterruptedFollowup(text) : wrapUserTurn(text);
+            // The chat itself is the durable memory — the Claude session is not, it
+            // compacts. Inline a recent window and hand over the full transcript path
+            // so a compacted session can still answer "which ticket?" exactly.
+            const memory = await buildChatMemory({
+                channel: ch,
+                botUserId: this.info.userId,
+                channelId,
+                homeDir: this.cfg.homeDir,
+            }).catch(() => EMPTY_MEMORY);
+            const turnText = interrupted ? wrapInterruptedFollowup(text) : wrapUserTurn(text);
+            const prompt = memory.recent ? `${memory.recent}\n\n${turnText}` : turnText;
             let reply = "";
             const stat = beginTurn(this.info.handle, channelId, resolved.kind);
             try {
@@ -747,6 +843,7 @@ export class BotRunner {
                     channelId,
                     senderUserId,
                     signal: live.abort.signal,
+                    ...(memory.file ? { transcriptFile: memory.file } : {}),
                     ...(files.length ? { files } : {}),
                 }, { onChunk: (delta) => published.onChunk(delta), onTool: (ev) => published.onTool(ev) });
                 if (live.abort.signal.aborted) {

package/dist/brain.d.ts

@@ -17,6 +17,11 @@ export interface BrainContext {
     files?: BrainFile[];
     /** Abort the in-flight brain when a later message interrupts this turn. */
     signal?: AbortSignal;
+    /**
+     * Full transcript of this chat on disk. The brain may point the model at it
+     * (Read/Grep are allowed) so a compacted session can still recover detail.
+     */
+    transcriptFile?: string;
 }
 /**
  * A brain answers one message. If it can stream, it calls `onChunk(delta)` as

package/dist/bridge.d.ts

@@ -1,5 +1,6 @@
 import type { BridgeConfig, Pairing, BrainSpec, BrainBackend } from "./config.js";
-export declare const VERSION = "0.7.25";
+import { BotRunner } from "./bot.js";
+export declare const VERSION: string;
 export interface PairRequest {
     pairingSecret: string;
     appId: string;
@@ -48,6 +49,19 @@ export declare class BridgeApp {
     /** Every runtime id this bridge answers for (persisted or live-auth'd).
      *  The local API accepts ANY of these as the x-nopeek-runtime capability. */
     runtimeIds(): string[];
+    /**
+     * Resolve a bot handle across ALL pairings. This bridge holds one runner per
+     * (pairing, bot), and a handle is unique within an app, so the first match
+     * wins. Kept separate from runtimeIds() because a caller with ANY pairing's
+     * runtime id may address any bot on this machine — the capability is "you
+     * are on this computer", which is already what loopback + the runtime header
+     * mean together.
+     */
+    findBot(handle: string): BotRunner;
+    /** Proactive post. See BotRunner.say — this is the alarm/report entry point. */
+    say(handle: string, channel: string, text: string): Promise<Record<string, unknown>>;
+    /** Channels a given bot can be addressed on. */
+    botChannels(handle: string): Promise<Array<Record<string, unknown>>>;
     start(): void;
     stop(): void;
     private startRuntime;

package/dist/bridge.js

@@ -8,10 +8,13 @@
 // persist to <home>/settings.json — no restart, no terminal. Brains
 // (brainMap/serverBackends) are GLOBAL per machine: handles are globally
 // unique, so a handle→brain map needs no per-account scoping.
+import { readFileSync } from "node:fs";
 import { hostname } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
 import { saveSettings } from "./config.js";
-import { BotRunner } from "./bot.js";
+import { BotRunner, SayError } from "./bot.js";
 import { ControlSocket } from "./control.js";
 import { resolveBrain } from "./brain.js";
 import { provisionSoul, provisionHermesProfile, resolveBin } from "./backends.js";
@@ -19,7 +22,23 @@ import { reportCapabilities } from "./capabilities.js";
 import { lastHermesApiHealth, probeHermesApi } from "./hermes-http.js";
 import { lastTurnGlobal, turnSnapshot } from "./last-turn.js";
 import { isBrainBackend } from "./config.js";
-export const VERSION = "0.7.25";
+/**
+ * Read from package.json rather than hardcoded, because the hardcoded copy
+ * DRIFTED: 0.8.0 shipped to npm still reporting "0.7.25", which made the one
+ * question that matters after an upgrade — "is the fix actually running?" —
+ * impossible to answer from /status. One source of truth, checked by a test.
+ */
+function readVersion() {
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        // dist/bridge.js -> ../package.json ; src/bridge.ts -> ../package.json
+        return String(JSON.parse(readFileSync(join(here, "..", "package.json"), "utf8")).version || "");
+    }
+    catch {
+        return "unknown";
+    }
+}
+export const VERSION = readVersion();
 function hermesApiStatus(cfg) {
     const api = lastHermesApiHealth();
     return {
@@ -170,6 +189,15 @@ class PairingRuntime {
             bots: this.botStatuses(),
         };
     }
+    /** This pairing's runner for `handle`, or null. Handles are unique per app. */
+    findBot(handle) {
+        const want = handle.trim().toLowerCase().replace(/^@/, "");
+        for (const b of this.bots.values()) {
+            if (b.info.handle.trim().toLowerCase() === want)
+                return b;
+        }
+        return null;
+    }
     botStatuses() {
         return [...this.bots.values()].map((b) => ({
             handle: b.info.handle,
@@ -328,6 +356,31 @@ export class BridgeApp {
         }
         return ids;
     }
+    /**
+     * Resolve a bot handle across ALL pairings. This bridge holds one runner per
+     * (pairing, bot), and a handle is unique within an app, so the first match
+     * wins. Kept separate from runtimeIds() because a caller with ANY pairing's
+     * runtime id may address any bot on this machine — the capability is "you
+     * are on this computer", which is already what loopback + the runtime header
+     * mean together.
+     */
+    findBot(handle) {
+        for (const r of this.runtimes) {
+            const b = r.findBot(handle);
+            if (b)
+                return b;
+        }
+        const known = this.runtimes.flatMap((r) => r.botStatuses().map((b) => b.handle)).join(", ") || "(none running)";
+        throw new SayError("NO_SUCH_BOT", `no bot "${handle}" on this bridge. Running: ${known}`);
+    }
+    /** Proactive post. See BotRunner.say — this is the alarm/report entry point. */
+    async say(handle, channel, text) {
+        return await this.findBot(handle).say(channel, text);
+    }
+    /** Channels a given bot can be addressed on. */
+    async botChannels(handle) {
+        return await this.findBot(handle).listChannels();
+    }
     start() {
         if (!this.paired) {
             console.log(`[bridge] not paired yet — open the NoPeek app: Bots -> Connect this computer`);

package/dist/chat-memory.d.ts

@@ -0,0 +1,46 @@
+/** Just the shape we need — avoids importing the SDK's Channel type here. */
+interface HistoryReader {
+    history(opts: {
+        beforeSeq?: number;
+        limit?: number;
+    }): Promise<HistoryMessage[]>;
+}
+interface HistoryMessage {
+    messageId: string;
+    senderUserId: string;
+    seq: number;
+    createdAt?: string;
+    recalledAt?: string | null;
+    body?: {
+        type?: string;
+        text?: string;
+        streaming?: boolean;
+    } | null;
+}
+export interface ChatMemory {
+    /** Labelled transcript block to prepend to the turn. "" when there is none. */
+    recent: string;
+    /** Absolute path to the full transcript, or null if it could not be written. */
+    file: string | null;
+    /** How many messages the full transcript holds. */
+    count: number;
+}
+export declare const EMPTY_MEMORY: ChatMemory;
+/**
+ * Pull this channel's history, write the full transcript, and return a compact
+ * recent window. Never throws: a bot that cannot read its history should still
+ * answer, just with less memory.
+ */
+export declare function buildChatMemory(opts: {
+    channel: HistoryReader;
+    botUserId: string;
+    channelId: string;
+    homeDir: string;
+    /** Messages inlined into the prompt. */
+    inline?: number;
+    /** Messages kept in the on-disk transcript. */
+    depth?: number;
+    /** Per-message character cap for the INLINE block only. */
+    inlineChars?: number;
+}): Promise<ChatMemory>;
+export {};

package/dist/chat-memory.js

@@ -0,0 +1,149 @@
+/**
+ * Durable chat memory for a bot turn.
+ *
+ * ## Why this exists
+ *
+ * The Claude brain runs `claude -p --resume <per-channel uuid>`, so the whole
+ * conversation lives in one Claude Code session — and Claude Code COMPACTS when
+ * that session outgrows the context window. Compaction replaces detail with a
+ * summary, which is how a bot ends up saying "the context rolled and I don't
+ * have the id from earlier".
+ *
+ * The fix is not a bigger window. The conversation is already stored durably in
+ * the NoPeek channel itself; the bot was simply the one participant who could
+ * not read its own chat — the prompt it received was the single incoming
+ * message and nothing else. This module gives it two ways back:
+ *
+ *   1. `recent` — a compact transcript inlined into every turn, so ordinary
+ *      "what did we just decide" questions never depend on session memory.
+ *   2. `file` — the full transcript written to the bot's own home dir. Read and
+ *      Grep are on the brain's ALLOWED tool list (only Bash/Edit/Write/Task/
+ *      WebFetch are denied), so the bot can search far past the inline window
+ *      without any MCP plumbing.
+ *
+ * ## On writing plaintext to disk
+ *
+ * The transcript holds decrypted chat text, so it is deliberately written only
+ * under the bot's own home directory (0600, in a 0700 dir) on the owner's
+ * machine. That is not a new exposure: the Claude session file in
+ * ~/.claude/projects already contains the same plaintext on the same disk, and
+ * the brain is handed the message text regardless. It never leaves the host.
+ */
+import { chmodSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+export const EMPTY_MEMORY = { recent: "", file: null, count: 0 };
+/** One page is the server's practical maximum; paging is by descending seq. */
+const PAGE = 100;
+/**
+ * Render one message as a transcript line.
+ *
+ * Senders are labelled by ROLE, not name: the members endpoint carries no
+ * nickname, and resolving one lookup per participant per turn is not worth a
+ * round trip. In a DM "user" is unambiguous; in a group the short id keeps two
+ * humans apart, and the bot can still correlate it with anything it knows.
+ */
+function line(m, botUserId, multiHuman) {
+    if (m.recalledAt)
+        return null;
+    const body = m.body ?? null;
+    const text = typeof body?.text === "string" ? body.text.trim() : "";
+    // A bare "…" is a streaming placeholder the bot posted, not content.
+    if (!text || text === "…" || text === "...") {
+        // Keep non-text attachments visible so "you sent me a photo" still parses.
+        const kind = body?.type;
+        if (!kind || kind === "text")
+            return null;
+        const who = m.senderUserId === botUserId ? "assistant" : "user";
+        return `[${m.seq}] ${who}: (${kind})`;
+    }
+    const who = m.senderUserId === botUserId
+        ? "assistant"
+        : multiHuman
+            ? `user:${m.senderUserId.slice(-6)}`
+            : "user";
+    // Long messages are clipped in the INLINE block only; the file keeps them
+    // whole, which is the point of having the file.
+    return `[${m.seq}] ${who}: ${text}`;
+}
+function clip(s, max) {
+    return s.length <= max ? s : `${s.slice(0, max)}… (clipped — full text in the transcript file)`;
+}
+/**
+ * Pull this channel's history, write the full transcript, and return a compact
+ * recent window. Never throws: a bot that cannot read its history should still
+ * answer, just with less memory.
+ */
+export async function buildChatMemory(opts) {
+    const inline = opts.inline ?? 30;
+    const depth = opts.depth ?? 400;
+    const inlineChars = opts.inlineChars ?? 700;
+    let all = [];
+    try {
+        let before;
+        while (all.length < depth) {
+            const page = await opts.channel.history({
+                limit: Math.min(PAGE, depth - all.length),
+                ...(before ? { beforeSeq: before } : {}),
+            });
+            if (!page.length)
+                break;
+            all = all.concat(page);
+            const lowest = Math.min(...page.map((m) => m.seq));
+            if (!Number.isFinite(lowest) || lowest <= 1)
+                break;
+            if (before !== undefined && lowest >= before)
+                break; // no progress — stop
+            before = lowest;
+        }
+    }
+    catch {
+        return EMPTY_MEMORY;
+    }
+    // The API's order is not guaranteed; seq is. Dedupe, then sort oldest-first.
+    const byId = new Map();
+    for (const m of all)
+        byId.set(m.messageId, m);
+    const ordered = [...byId.values()].sort((a, b) => a.seq - b.seq);
+    if (!ordered.length)
+        return EMPTY_MEMORY;
+    const humans = new Set(ordered.map((m) => m.senderUserId).filter((u) => u !== opts.botUserId));
+    const multiHuman = humans.size > 1;
+    const rendered = ordered
+        .map((m) => line(m, opts.botUserId, multiHuman))
+        .filter((l) => l !== null);
+    if (!rendered.length)
+        return EMPTY_MEMORY;
+    // ---- full transcript on disk -------------------------------------------
+    let file = null;
+    try {
+        const dir = join(opts.homeDir, "chats");
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        file = join(dir, `${opts.channelId}.md`);
+        const header = `# Transcript — NoPeek chat ${opts.channelId}\n` +
+            `# ${rendered.length} messages, oldest first. Regenerated before every turn.\n` +
+            `# Lines are "[seq] speaker: text".\n\n`;
+        writeFileSync(file, header + rendered.join("\n") + "\n", { mode: 0o600 });
+        chmodSync(file, 0o600);
+    }
+    catch {
+        file = null; // disk trouble must not break the turn
+    }
+    // ---- compact recent window for the prompt -------------------------------
+    // Drop the final line: it is the message being answered, which the turn
+    // already carries verbatim, and repeating it invites the bot to answer twice.
+    const window = rendered.slice(-(inline + 1), -1).map((l) => clip(l, inlineChars));
+    const recent = window.length
+        ? [
+            "[CHAT TRANSCRIPT — the real record of this NoPeek chat, oldest first.",
+            "Your session memory may have been compacted; this has not. If you are",
+            "missing a detail (an id, a number, what was decided), take it from here",
+            `rather than saying you lost context.${file ? ` The full history is at ${file} — Read or Grep it when you need more than this window.` : ""}`,
+            "Do NOT answer these again; they are context. Only the message after the",
+            "transcript is the one to answer.]",
+            "",
+            ...window,
+            "[END TRANSCRIPT]",
+        ].join("\n")
+        : "";
+    return { recent, file, count: rendered.length };
+}

package/dist/localapi.js

@@ -17,12 +17,15 @@
 //   read bot lists or change brain commands.
 //   DELETE /pair?runtimeId=rt_… removes ONE pairing; no query = remove ALL
 //   (the legacy pre-0.6 shape keeps working).
+//   POST /say     proactive send (see the route) — runtime header required.
+//   GET  /channels?bot=  which channels that bot can be addressed on.
 //
 // CORS reflects the caller origin (the app may be served from any white-label
 // domain) and answers Chrome's Private Network Access preflight.
 import { createServer } from "node:http";
 import { createHash, timingSafeEqual } from "node:crypto";
 import { PairError } from "./bridge.js";
+import { SayError } from "./bot.js";
 import { detectRuntimes } from "./detect.js";
 const BODY_LIMIT = 64 * 1024;
 function setCors(req, res) {
@@ -171,6 +174,71 @@ async function handle(app, req, res) {
         json(res, 200, { runtimes: await detectRuntimes() });
         return;
     }
+    // ── PROACTIVE SEND ────────────────────────────────────────────────────────
+    // POST /say {bot, channel, text} — post into an E2EE channel WITHOUT an
+    // inbound message to reply to. This is what makes the bridge usable for
+    // monitoring: alarms and scheduled reports have no inbound frame to answer,
+    // so without this route nothing on this machine can start a conversation.
+    //
+    // The device keys stay here. Callers (ops scripts, cron, the MCP server)
+    // hand over plaintext and never touch MLS state, which is the reason this
+    // is a bridge route and not a second key-holder somewhere else.
+    //
+    // `channel` accepts a channelId or a channel NAME, resolved against the
+    // channels that bot is actually in. Unknown/ambiguous names 404/409 with the
+    // list of real ones rather than guessing — a misrouted alert is silence.
+    if (method === "POST" && path === "/say") {
+        let body;
+        try {
+            body = await readBody(req);
+        }
+        catch (err) {
+            json(res, 400, { error: "BAD_REQUEST", message: err.message });
+            return;
+        }
+        const bot = typeof body.bot === "string" ? body.bot.trim() : "";
+        const channel = typeof body.channel === "string" ? body.channel.trim() : "";
+        const text = typeof body.text === "string" ? body.text : "";
+        if (!bot || !channel || !text.trim()) {
+            json(res, 400, { error: "BAD_REQUEST", message: "bot, channel and text are all required" });
+            return;
+        }
+        try {
+            const sent = await app.say(bot, channel, text);
+            json(res, 200, { ok: true, ...sent });
+        }
+        catch (err) {
+            if (err instanceof SayError) {
+                const status = err.code === "NO_SUCH_BOT" || err.code === "NO_SUCH_CHANNEL" ? 404 : err.code === "AMBIGUOUS_CHANNEL" ? 409 : 503;
+                json(res, status, { error: err.code, message: err.message });
+            }
+            else {
+                json(res, 502, { error: "SEND_FAILED", message: err.message });
+            }
+        }
+        return;
+    }
+    // GET /channels?bot=handle — the address book for /say, and the answer to
+    // "which groups is this bot in?" after it's been added to new ones.
+    if (method === "GET" && path === "/channels") {
+        const bot = (query.get("bot") ?? "").trim();
+        if (!bot) {
+            json(res, 400, { error: "BAD_REQUEST", message: "?bot=handle is required" });
+            return;
+        }
+        try {
+            json(res, 200, { bot, channels: await app.botChannels(bot) });
+        }
+        catch (err) {
+            if (err instanceof SayError) {
+                json(res, err.code === "NO_SUCH_BOT" ? 404 : 503, { error: err.code, message: err.message });
+            }
+            else {
+                json(res, 502, { error: "LIST_FAILED", message: err.message });
+            }
+        }
+        return;
+    }
     if (method === "PUT" && path === "/brains") {
         let body;
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nopeek/agent-bridge",
-  "version": "0.7.25",
+  "version": "0.8.1",
   "description": "Run your own agents as E2EE NoPeek bots. Pairs with one-time codes (multiple accounts per computer), runs every bot each account owns, and pipes messages to any command or webhook.",
   "type": "module",
   "license": "MIT",
@@ -46,6 +46,6 @@
     "start": "node dist/cli.js",
     "dev": "tsx src/cli.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "tsx --test --test-concurrency=1 src/tool-progress.test.ts src/inbound-files.test.ts src/mid-turn.test.ts src/outbound-media.test.ts src/hermes-session-store.test.ts"
+    "test": "tsx --test --test-concurrency=1 src/tool-progress.test.ts src/inbound-files.test.ts src/mid-turn.test.ts src/outbound-media.test.ts src/hermes-session-store.test.ts src/chat-memory.test.ts"
   }
 }