@nopeek/agent-bridge 0.7.8 → 0.7.11

package/README.md

@@ -39,6 +39,15 @@ npx @nopeek/agent-bridge \
 
 The `npr_…` code comes from Settings → Connect your computer (bots) in the app. `install` also accepts `--pair`/`--app-id` to pre-pair the service from the terminal.
 
+Hermes brains prefer the local agent API (`HERMES_API_URL`, default
+`http://127.0.0.1:8642`) when `/health` is up, and fall back to `hermes chat`.
+While Hermes is working, the bot posts Telegram-style tool lines a few at a
+time (read file, patch, skill, memory). A quiet gap starts a new message.
+The final reply is the answer plus a short recap when tools were used.
+Idle kill waits for **no output and no CPU** (default 15 min). Authenticated
+`GET /status` includes `bridge`, `bots[]` (each with `lastTurn`), `hermesApi`,
+and `lastTurn`. See `docs/HERMES-BRAIN-PLAN.md`.
+
 ## Local control API
 
 The bridge serves a loopback-only HTTP API on `127.0.0.1:8790` — this is what the NoPeek app uses; you can script it too.

package/dist/backends.d.ts

@@ -10,6 +10,12 @@ export declare function soulPath(homeDir: string, handle: string): string;
 export declare function provisionSoul(handle: string, homeDir: string): string;
 /** Resolve a binary: $<ENVVAR> > PATH (command -v) > common install dirs. */
 export declare function resolveBin(name: string, envVar: string): string | null;
+/**
+ * Accumulated CPU seconds for a pid (`ps -o cputime=`). Used so a silent but
+ * working Hermes child (quiet mode + long tools) does not trip the idle kill.
+ * Returns null if the process is gone or `ps` fails.
+ */
+export declare function cpuTimeSeconds(pid: number | undefined): number | null;
 /**
  * Deterministic per-(bot, channel) session UUID so each chat is one running
  * Claude conversation. UUIDv5-ish (sha1 of the key formatted as a UUID) —
@@ -33,4 +39,10 @@ export declare function hermesHome(): string;
  * stays authenticated from one login). Idempotent.
  */
 export declare function provisionHermesProfile(handle: string): string;
+/**
+ * Hermes brain. Prefers the long-running agent API (`HERMES_API_URL`, default
+ * loopback :8642) when `/health` is up — that path does not shell out, so a
+ * CLI flag change cannot empty-reply the bot. Falls back to `hermes chat -Q`.
+ */
 export declare function hermesBrain(cfg: BridgeConfig): Brain;
+export declare function hermesHttpOnlyBrain(cfg: BridgeConfig): Brain;

package/dist/backends.js

@@ -16,7 +16,8 @@ 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 { stripAnsi } from "./brain.js";
+import { asHooks, stripAnsi } from "./brain.js";
+import { hermesHttpBrain, probeHermesApi } from "./hermes-http.js";
 const BRAIN_UNREACHABLE = "⚠️ I couldn't reach my brain just now — please try again in a moment.";
 // ------------------------------------------------------------------ souls ----
 /** Built-in personality template — personalized per bot by provisionSoul(). */
@@ -77,6 +78,41 @@ export function resolveBin(name, envVar) {
     }
     return null;
 }
+/**
+ * Accumulated CPU seconds for a pid (`ps -o cputime=`). Used so a silent but
+ * working Hermes child (quiet mode + long tools) does not trip the idle kill.
+ * Returns null if the process is gone or `ps` fails.
+ */
+export function cpuTimeSeconds(pid) {
+    if (pid == null || pid <= 0)
+        return null;
+    try {
+        const r = spawnSync("ps", ["-o", "cputime=", "-p", String(pid)], { encoding: "utf8", timeout: 2_000 });
+        if (r.status !== 0)
+            return null;
+        const raw = (r.stdout || "").trim();
+        // Formats: "SS.ss", "MM:SS", "HH:MM:SS", "[D-]HH:MM:SS"
+        const daySplit = raw.split("-");
+        const clock = daySplit.length === 2 ? daySplit[1] : daySplit[0];
+        const days = daySplit.length === 2 ? Number(daySplit[0]) : 0;
+        const parts = clock.split(":").map(Number);
+        if (parts.some((n) => !Number.isFinite(n)))
+            return null;
+        let secs = days * 86400;
+        if (parts.length === 3)
+            secs += parts[0] * 3600 + parts[1] * 60 + parts[2];
+        else if (parts.length === 2)
+            secs += parts[0] * 60 + parts[1];
+        else if (parts.length === 1)
+            secs += parts[0];
+        else
+            return null;
+        return secs;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Deterministic per-(bot, channel) session UUID so each chat is one running
  * Claude conversation. UUIDv5-ish (sha1 of the key formatted as a UUID) —
@@ -188,7 +224,8 @@ function runClaudeOnce(bin, args, text, cwd, timeoutMs, tag, onDelta) {
  * host powers from wherever the bridge happens to run.
  */
 export function claudeBrain(cfg) {
-    return async (text, ctx, onChunk) => {
+    return async (text, ctx, hooks) => {
+        const { onChunk } = asHooks(hooks);
         const bin = resolveBin("claude", "CLAUDE_BIN");
         if (!bin) {
             console.error(`[brain:claude:@${ctx.botHandle}] claude not found on PATH`);
@@ -266,8 +303,15 @@ you reply. Your replies are chat messages — every word you print is sent verba
 ## Guardrails
 - Never expose secrets, keys, or tokens.
 - Confirm before destructive or outward-facing actions.
-- Report honestly — if something failed, say so.
+- Report honestly. If something failed, say so.
 - If a request is far outside your purpose, say so briefly and offer what you can do.
+
+## After tool work
+When you used tools this turn (read or wrote files, ran commands, changed skills, saved memory), end with a short recap:
+- What was going on (one line).
+- What you did (one or two lines).
+- Result (one line).
+Skip the recap for simple conversation with no tools.
 `;
 /**
  * Create (or reuse) the bot's isolated Hermes profile: its own SOUL.md and
@@ -349,7 +393,7 @@ function detectHermesProfileMode(bin) {
     console.log(`[hermes] profile selection mode: ${hermesProfileMode}`);
     return hermesProfileMode;
 }
-export function hermesBrain(cfg) {
+function hermesCliBrain(cfg) {
     const runOnce = (profile, text, sessionName, tag, onChunk) => new Promise((resolvePromise) => {
         const bin = resolveBin("hermes", "HERMES_BIN");
         const mode = detectHermesProfileMode(bin);
@@ -418,6 +462,7 @@ export function hermesBrain(cfg) {
             if (settled)
                 return;
             settled = true;
+            clearInterval(cpuPoll);
             if (lineBuf)
                 handleLine(lineBuf);
             // The session footer lands on STDERR in -Q mode — scan there too.
@@ -443,13 +488,28 @@ export function hermesBrain(cfg) {
         const armIdleTimer = () => {
             clearTimeout(timer);
             timer = setTimeout(() => {
-                console.error(`${tag} idle ${cfg.brainTimeoutMs / 1000}s (no output), killing`);
+                console.error(`${tag} idle ${cfg.brainTimeoutMs / 1000}s (no output and no CPU), killing`);
                 timedOut = true;
                 child.kill("SIGKILL");
                 finish();
             }, cfg.brainTimeoutMs);
         };
         armIdleTimer();
+        // Hermes -Q is silent during long tool use. Reset the idle timer whenever
+        // the child's accumulated CPU time advances — that is real work, not a hang.
+        let lastCpu = cpuTimeSeconds(child.pid);
+        const cpuPoll = setInterval(() => {
+            if (settled || child.pid == null)
+                return;
+            const now = cpuTimeSeconds(child.pid);
+            if (now != null && lastCpu != null && now > lastCpu + 0.05) {
+                lastCpu = now;
+                armIdleTimer();
+            }
+            else if (now != null && lastCpu == null) {
+                lastCpu = now;
+            }
+        }, 10_000);
         child.stdout.on("data", (d) => {
             armIdleTimer();
             lineBuf += d.toString();
@@ -475,7 +535,8 @@ export function hermesBrain(cfg) {
             finish();
         });
     });
-    return async (text, ctx, onChunk) => {
+    return async (text, ctx, hooks) => {
+        const { onChunk } = asHooks(hooks);
         const handle = ctx.botHandle.replace(/^@/, "");
         const tag = `[brain:hermes:@${handle}]`;
         if (!resolveBin("hermes", "HERMES_BIN")) {
@@ -546,3 +607,25 @@ export function hermesBrain(cfg) {
         return run.reply;
     };
 }
+/**
+ * Hermes brain. Prefers the long-running agent API (`HERMES_API_URL`, default
+ * loopback :8642) when `/health` is up — that path does not shell out, so a
+ * CLI flag change cannot empty-reply the bot. Falls back to `hermes chat -Q`.
+ */
+export function hermesBrain(cfg) {
+    const cli = hermesCliBrain(cfg);
+    const http = hermesHttpBrain(cfg);
+    return async (text, ctx, hooks) => {
+        const health = await probeHermesApi(cfg);
+        if (health.ok) {
+            const reply = await http(text, ctx, hooks);
+            if (reply)
+                return reply;
+            console.error(`[brain:hermes:@${ctx.botHandle.replace(/^@/, "")}] API returned empty — falling back to CLI`);
+        }
+        return cli(text, ctx, hooks);
+    };
+}
+export function hermesHttpOnlyBrain(cfg) {
+    return hermesHttpBrain(cfg);
+}

package/dist/bot.d.ts

@@ -1,5 +1,6 @@
 import type { BridgeConfig, Pairing, BrainBackend } from "./config.js";
 import { type ChannelMode } from "./control.js";
+import { type BrainTurn } from "./last-turn.js";
 export interface BotInfo {
     userId: string;
     handle: string;
@@ -46,6 +47,8 @@ export declare class BotRunner {
     msSinceHealthy(): number;
     /** When the watchdog last force-restarted this runner (null = never). */
     get lastForcedRestartAt(): number | null;
+    /** Most recent brain turn for this bot (shared last-turn store). */
+    lastTurn(): BrainTurn | null;
     /**
      * 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

@@ -5,7 +5,9 @@
 import { NoPeek } from "@nopeek/chat";
 import { isChannelMode } from "./control.js";
 import { FALLBACK_REPLY, resolveBrain } from "./brain.js";
+import { beginTurn, finishTurn, lastTurnFor } from "./last-turn.js";
 import { FileStore } from "./storage.js";
+import { ToolProgressFlusher } from "./tool-progress.js";
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 const MAX_BACKOFF_MS = 60_000;
 // Owner-membership answers are cached per channel for a short window; a
@@ -94,6 +96,10 @@ export class BotRunner {
     get lastForcedRestartAt() {
         return this.lastForcedRestart;
     }
+    /** Most recent brain turn for this bot (shared last-turn store). */
+    lastTurn() {
+        return lastTurnFor(this.info.handle);
+    }
     /**
      * Watchdog hard restart: tear the SDK client down completely and rebuild it
      * from scratch (fresh session mint + NoPeek.connect) — the proven-working
@@ -546,16 +552,20 @@ export class BotRunner {
         // append onto the open promise keeps them ordered and loses none.
         // (Ref object rather than a `let`: TS can't see closure assignments.)
         const streamRef = { p: null };
+        const stopTyping = () => {
+            try {
+                ch.typing(false);
+            }
+            catch {
+                /* best-effort */
+            }
+        };
         const onChunk = (delta) => {
             if (!delta)
                 return;
+            void progress.flush();
             if (!streamRef.p) {
-                try {
-                    ch.typing(false); // the live bubble replaces the typing indicator
-                }
-                catch {
-                    /* best-effort */
-                }
+                stopTyping();
                 streamRef.p = ch.stream();
                 streamRef.p.catch((err) => {
                     this.notePostFailure(m.channelId, err);
@@ -564,18 +574,33 @@ export class BotRunner {
             }
             streamRef.p.then((s) => s.append(delta)).catch(() => { });
         };
+        const progress = new ToolProgressFlusher(async (body) => {
+            stopTyping();
+            await ch.send({ text: body });
+        });
         let reply = "";
+        const turn = beginTurn(this.info.handle, m.channelId, resolved.kind);
         try {
             reply = await resolved.brain(text, {
                 botHandle: this.info.handle,
                 botUserId: this.info.userId,
                 channelId: m.channelId,
                 senderUserId: m.senderUserId,
-            }, onChunk);
+            }, { onChunk, onTool: (ev) => progress.push(ev) });
+            const trimmed = reply.trim();
+            const timedOut = /went quiet for over \d+s/i.test(trimmed);
+            finishTurn(turn, {
+                ok: Boolean(trimmed) && !trimmed.startsWith("⚠️"),
+                chars: trimmed.length,
+                timedOut,
+                error: !trimmed ? "empty reply" : trimmed.startsWith("⚠️") ? trimmed.slice(0, 180) : null,
+            });
         }
         catch (err) {
+            finishTurn(turn, { ok: false, error: err.message, timedOut: false });
             // Brain blew up mid-stream: finalize the partial bubble with an honest
             // error line instead of leaving a forever-blinking cursor.
+            await progress.flush();
             const stream = streamRef.p ? await streamRef.p.catch(() => null) : null;
             if (stream)
                 await stream.fail(FALLBACK_REPLY).catch(() => { });
@@ -589,6 +614,7 @@ export class BotRunner {
                 /* best-effort */
             }
         }
+        await progress.flush();
         const stream = streamRef.p ? await streamRef.p.catch(() => null) : null;
         if (stream) {
             await stream.done(reply.trim() || undefined);

package/dist/brain.d.ts

@@ -1,4 +1,5 @@
 import type { BridgeConfig } from "./config.js";
+import type { ToolProgressEvent } from "./tool-progress.js";
 export interface BrainContext {
     botHandle: string;
     botUserId: string;
@@ -9,8 +10,14 @@ export interface BrainContext {
  * A brain answers one message. If it can stream, it calls `onChunk(delta)` as
  * text arrives (plain text, ANSI-stripped) and STILL returns the full reply —
  * the returned string is authoritative for the final message body.
+ * `onTool` is optional: Hermes HTTP uses it for live tool-progress lines.
  */
-export type Brain = (text: string, ctx: BrainContext, onChunk?: (delta: string) => void) => Promise<string>;
+export type BrainHooks = {
+    onChunk?: (delta: string) => void;
+    onTool?: (ev: ToolProgressEvent) => void;
+};
+export type Brain = (text: string, ctx: BrainContext, hooks?: BrainHooks | ((delta: string) => void)) => Promise<string>;
+export declare function asHooks(hooks?: BrainHooks | ((delta: string) => void)): BrainHooks;
 export declare const FALLBACK_REPLY = "Sorry \u2014 I hit an error processing that. Please try again.";
 export declare function stripAnsi(s: string): string;
 export interface ResolvedBrain {

package/dist/brain.js

@@ -6,7 +6,14 @@
 // This is how ANY agentic runtime plugs in (Hermes, OpenClaw, a curl to your
 // own service): the bridge never knows or cares what's on the other side.
 import { spawn } from "node:child_process";
-import { claudeBrain, hermesBrain } from "./backends.js";
+import { claudeBrain, hermesBrain, hermesHttpOnlyBrain } from "./backends.js";
+export function asHooks(hooks) {
+    if (!hooks)
+        return {};
+    if (typeof hooks === "function")
+        return { onChunk: hooks };
+    return hooks;
+}
 export const FALLBACK_REPLY = "Sorry — I hit an error processing that. Please try again.";
 // ANSI escape sequences (CSI, OSC, and lone ESC controls). Agent runtimes like
 // Hermes color their stdout; the chat must receive plain text.
@@ -23,7 +30,8 @@ export function stripAnsi(s) {
  * NOPEEK_BOT_HANDLE, NOPEEK_BOT_USER_ID, NOPEEK_CHANNEL_ID, NOPEEK_SENDER_USER_ID.
  */
 function cmdBrain(cmd, timeoutMs) {
-    return (text, ctx, onChunk) => new Promise((resolvePromise) => {
+    return (text, ctx, hooks) => new Promise((resolvePromise) => {
+        const { onChunk } = asHooks(hooks);
         const child = spawn("bash", ["-c", cmd], {
             stdio: ["pipe", "pipe", "pipe"],
             env: {
@@ -151,6 +159,8 @@ export function resolveBrain(cfg, handle) {
         return { brain: claudeBrain(cfg), kind: "claude (per-bot)" };
     if (override?.backend === "hermes")
         return { brain: hermesBrain(cfg), kind: "hermes (per-bot)" };
+    if (override?.backend === "hermes-http")
+        return { brain: hermesHttpOnlyBrain(cfg), kind: "hermes-http (per-bot)" };
     if (override?.backend === "echo" || override?.echo)
         return { brain: echoBrain, kind: "echo (per-bot)" };
     // No local override — honor the server-mediated backend if one was pushed.
@@ -159,6 +169,8 @@ export function resolveBrain(cfg, handle) {
         return { brain: claudeBrain(cfg), kind: "claude (server)" };
     if (server === "hermes")
         return { brain: hermesBrain(cfg), kind: "hermes (server)" };
+    if (server === "hermes-http")
+        return { brain: hermesHttpOnlyBrain(cfg), kind: "hermes-http (server)" };
     if (server === "echo")
         return { brain: echoBrain, kind: "echo (server)" };
     if (cfg.brainCmd)

package/dist/bridge.d.ts

@@ -1,5 +1,5 @@
 import type { BridgeConfig, Pairing, BrainSpec, BrainBackend } from "./config.js";
-export declare const VERSION = "0.7.8";
+export declare const VERSION = "0.7.10";
 export interface PairRequest {
     pairingSecret: string;
     appId: string;
@@ -94,5 +94,5 @@ export declare class BridgeApp {
     /** Full status (authenticated). `callerRuntimeId` — when known — keeps the
      *  legacy top-level `runtime`/`appId` fields pointing at the CALLER's own
      *  pairing so pre-0.6 clients keep working unchanged. */
-    statusFull(callerRuntimeId?: string): Record<string, unknown>;
+    statusFull(callerRuntimeId?: string): Promise<Record<string, unknown>>;
 }

package/dist/bridge.js

@@ -14,10 +14,28 @@ import { saveSettings } from "./config.js";
 import { BotRunner } from "./bot.js";
 import { ControlSocket } from "./control.js";
 import { resolveBrain } from "./brain.js";
-import { provisionSoul, provisionHermesProfile } from "./backends.js";
+import { provisionSoul, provisionHermesProfile, resolveBin } from "./backends.js";
 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.8";
+export const VERSION = "0.7.10";
+function hermesApiStatus(cfg) {
+    const api = lastHermesApiHealth();
+    return {
+        url: cfg.hermesApiUrl,
+        healthy: api?.ok === true,
+        reason: api ? (api.reason ?? null) : "not probed yet",
+        checkedAt: api?.checkedAt ?? null,
+    };
+}
+function hermesHostStatus(cfg) {
+    return {
+        cli: Boolean(resolveBin("hermes", "HERMES_BIN")),
+        apiUrl: cfg.hermesApiUrl,
+        api: hermesApiStatus(cfg),
+    };
+}
 /** How often to re-probe + report brain availability to the server. */
 const CAPABILITIES_INTERVAL_MS = 5 * 60_000;
 // ---- Reconnect watchdog -----------------------------------------------------
@@ -161,6 +179,7 @@ class PairingRuntime {
             msSinceHealthy: b.msSinceHealthy(),
             lastForcedRestart: b.lastForcedRestartAt,
             brain: resolveBrain(this.cfg, b.info.handle).kind,
+            lastTurn: turnSnapshot(b.lastTurn()),
         }));
     }
     /**
@@ -590,8 +609,19 @@ export class BridgeApp {
     /** Full status (authenticated). `callerRuntimeId` — when known — keeps the
      *  legacy top-level `runtime`/`appId` fields pointing at the CALLER's own
      *  pairing so pre-0.6 clients keep working unchanged. */
-    statusFull(callerRuntimeId) {
+    async statusFull(callerRuntimeId) {
         const own = (callerRuntimeId && this.runtimes.find((r) => r.runtimeId === callerRuntimeId)) || this.runtimes[0] || null;
+        await probeHermesApi(this.cfg).catch(() => null);
+        const bots = this.runtimes.flatMap((r) => r.botStatuses());
+        const watchdog = {
+            intervalMs: WATCHDOG_INTERVAL_MS,
+            softStaleMs: SOFT_STALE_MS,
+            hardStaleMs: HARD_STALE_MS,
+            hardStaleStreak: this.hardStaleStreak,
+            lastCheckAt: this.lastWatchdogAt || null,
+        };
+        const hermesApi = hermesApiStatus(this.cfg);
+        const lastTurn = turnSnapshot(lastTurnGlobal());
         return {
             ...this.statusMinimal(),
             runtime: own?.runtimeId ?? null,
@@ -610,16 +640,13 @@ export class BridgeApp {
                 provisionCmd: this.cfg.brainProvisionCmd,
             },
             // Legacy flat list = every pairing's bots (pre-0.6 clients read this).
-            bots: this.runtimes.flatMap((r) => r.botStatuses()),
-            // Reconnect watchdog state (per-bot msSinceHealthy/lastForcedRestart ride
-            // each bot entry above; this summarizes the process-level guard).
-            watchdog: {
-                intervalMs: WATCHDOG_INTERVAL_MS,
-                softStaleMs: SOFT_STALE_MS,
-                hardStaleMs: HARD_STALE_MS,
-                hardStaleStreak: this.hardStaleStreak,
-                lastCheckAt: this.lastWatchdogAt || null,
-            },
+            bots,
+            watchdog,
+            hermes: hermesHostStatus(this.cfg),
+            // Plan fields (docs/HERMES-BRAIN-PLAN.md) — additive, same payload.
+            bridge: { ...this.statusMinimal(), watchdog },
+            hermesApi,
+            lastTurn,
         };
     }
 }

package/dist/capabilities.d.ts

@@ -7,13 +7,14 @@ export interface BackendCapability {
 export interface Capabilities {
     claude: BackendCapability;
     hermes: BackendCapability;
+    hermesHttp: BackendCapability;
 }
 /**
  * Probe which native brains are ready on this computer. Best-effort and FREE:
  * binary resolution + credential file/keychain/env presence only, never a paid
  * model call. Echo is always available and isn't probed.
  */
-export declare function probeCapabilities(_cfg: BridgeConfig): Promise<Capabilities>;
+export declare function probeCapabilities(cfg: BridgeConfig): Promise<Capabilities>;
 /**
  * Probe, then PUT the result to the server so the phone's picker reflects it.
  * Authed with ONE pairing's runtime token — the SAME Bearer auth the bridge

package/dist/capabilities.js

@@ -11,6 +11,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { homedir, platform } from "node:os";
 import { join } from "node:path";
 import { resolveBin, hermesHome } from "./backends.js";
+import { probeHermesApi } from "./hermes-http.js";
 // Reasons are stable strings the app renders verbatim ("Claude — not logged in").
 const NOT_INSTALLED = "not installed";
 const NOT_LOGGED_IN = "not logged in";
@@ -109,8 +110,13 @@ function probeHermes() {
  * binary resolution + credential file/keychain/env presence only, never a paid
  * model call. Echo is always available and isn't probed.
  */
-export async function probeCapabilities(_cfg) {
-    return { claude: probeClaude(), hermes: probeHermes() };
+export async function probeCapabilities(cfg) {
+    const api = await probeHermesApi(cfg);
+    return {
+        claude: probeClaude(),
+        hermes: probeHermes(),
+        hermesHttp: api.ok ? { available: true } : { available: false, reason: api.reason ?? "unreachable" },
+    };
 }
 function summarize(c) {
     return c.available ? "ok" : (c.reason ?? "unavailable");
@@ -132,7 +138,7 @@ export async function reportCapabilities(cfg, pairing) {
         console.error(`[caps] probe failed: ${err.message}`);
         return;
     }
-    console.log(`[caps] claude=${summarize(caps.claude)} hermes=${summarize(caps.hermes)} (reporting as ${pairing.label ?? pairing.appId})`);
+    console.log(`[caps] claude=${summarize(caps.claude)} hermes=${summarize(caps.hermes)} hermes-http=${summarize(caps.hermesHttp)} (reporting as ${pairing.label ?? pairing.appId})`);
     try {
         const res = await fetch(`${pairing.apiUrl}/v1/runtime/capabilities`, {
             method: "PUT",
@@ -140,7 +146,7 @@ export async function reportCapabilities(cfg, pairing) {
                 authorization: `Bearer ${pairing.pairingCode}`,
                 "content-type": "application/json",
             },
-            body: JSON.stringify({ backends: { claude: caps.claude, hermes: caps.hermes } }),
+            body: JSON.stringify({ backends: { claude: caps.claude, hermes: caps.hermes, hermesHttp: caps.hermesHttp } }),
             signal: AbortSignal.timeout(15_000),
         });
         if (!res.ok) {

package/dist/cli.js

@@ -92,6 +92,7 @@ console.log(`[bridge] NoPeek agent-bridge v${VERSION} starting`);
 console.log(`[bridge] api=${cfg.apiUrl} accounts=${cfg.pairings.length ? cfg.pairings.map((p) => p.label ?? p.appId).join(", ") : "(not paired)"} data=${cfg.dataDir} local-api=:${cfg.port} home=${cfg.homeDir}`);
 console.log(`[bridge] default brain: ${cfg.brainCmd ? "cmd" : cfg.brainUrl ? "url" : "echo (choose an agent in the NoPeek app, or set --brain-cmd)"}` +
     (Object.keys(cfg.brainMap).length ? ` + ${Object.keys(cfg.brainMap).length} per-bot override(s)` : ""));
+console.log(`[bridge] hermes-api=${cfg.hermesApiUrl} timeout=${cfg.brainTimeoutMs}ms`);
 const app = new BridgeApp(cfg);
 let localApi;
 try {

package/dist/config.d.ts

@@ -1,6 +1,6 @@
 /** Built-in native backends (see backends.ts): claude = Claude Code headless,
  *  hermes = per-bot Hermes profile, echo = smoke test. */
-export type BrainBackend = "claude" | "hermes" | "echo";
+export type BrainBackend = "claude" | "hermes" | "hermes-http" | "echo";
 /** Per-bot brain override, keyed by bot handle in BRAIN_MAP.
  *  `backend` selects a native built-in (claude/hermes/echo);
  *  `echo: true` pins the bot to echo mode even when a global brain is set. */
@@ -69,6 +69,15 @@ export interface BridgeConfig {
     brainTimeoutMs: number;
     /** Where `install` sends the user to finish setup (opened in the browser). */
     appUrl: string;
+    /**
+     * Hermes agent API server (gateway `api_server` platform). When set, the
+     * hermes brain talks HTTP (`/v1/chat/completions` + `/health`) instead of
+     * shelling out to `hermes chat`. Flag changes in the CLI then cannot silently
+     * kill bots. Default: HERMES_API_URL or http://127.0.0.1:8642.
+     */
+    hermesApiUrl: string;
+    /** Optional bearer for the Hermes API server (`API_SERVER_KEY`). */
+    hermesApiKey: string | null;
     /** Local control API port (status + pairing + brain config, loopback only). */
     port: number;
     /** Where per-bot device identity/key stores live. */
@@ -82,9 +91,10 @@ export interface BridgeConfig {
 export declare const DEFAULT_API_URL = "https://d3qweh72vesa98.cloudfront.net";
 export declare const DEFAULT_APP_URL = "https://d32w3to73s0pu5.cloudfront.net/messenger/";
 export declare const DEFAULT_PORT = 8790;
-export declare const DEFAULT_BRAIN_TIMEOUT_MS = 300000;
+export declare const DEFAULT_BRAIN_TIMEOUT_MS = 900000;
+export declare const DEFAULT_HERMES_API_URL = "http://127.0.0.1:8642";
 export declare function defaultHomeDir(): string;
-export declare const HELP = "nopeek-agent-bridge \u2014 run your agents as E2EE NoPeek bots\n\nUsage:\n  nopeek-agent-bridge install     Install as a background service (launchd/systemd),\n                                  then finish setup from the NoPeek app:\n                                  Bots -> Connect this computer.\n  nopeek-agent-bridge uninstall   Remove the background service (keeps data/settings).\n  nopeek-agent-bridge status      Show the running bridge's status.\n  nopeek-agent-bridge [run]       Run in the foreground. Unpaired bridges wait to be\n                                  paired from the NoPeek app; --pair still works:\n                                    npx @nopeek/agent-bridge --pair npr_\u2026 --app-id app_\u2026\n\nOptions:\n  --pair <code>            Pairing code from the NoPeek app             (env NOPEEK_PAIRING_CODE)\n  --app-id <id>            NoPeek app id                                (env NOPEEK_APP_ID)\n  --api-url <url>          API base, default https://d3qweh72vesa98.cloudfront.net  (env NOPEEK_API_URL)\n  --brain-cmd <cmd>        Shell brain: message on stdin -> reply on stdout   (env BRAIN_CMD)\n  --brain-url <url>        Webhook brain: POST {text,...} -> {text|reply}     (env BRAIN_URL)\n  --brain-map <json>       Per-bot overrides {\"<handle>\":{\"cmd\":\"\u2026\"}|{\"url\":\"\u2026\"}|\n                           {\"backend\":\"claude\"|\"hermes\"|\"echo\"}}              (env BRAIN_MAP)\n  --brain-provision-cmd <cmd>  Run once per new bot; stdout becomes its brain command\n                           (env BRAIN_PROVISION_CMD \u2014 e.g. a script that creates a\n                           fresh Hermes profile with its own soul + memory)\n  --app-url <url>          App opened after install                     (env NOPEEK_APP_URL)\n  --no-open                install: don't open the app in the browser\n  --brain-timeout-ms <ms>  Brain timeout, default 300000          (env BRAIN_TIMEOUT_MS)\n  --port <port>            Local control API port, default 8790    (env NOPEEK_BRIDGE_PORT)\n  --data-dir <dir>         Device-key store dir                        (env NOPEEK_BRIDGE_DATA_DIR)\n  --home <dir>             Bridge home, default ~/.nopeek-bridge       (env NOPEEK_BRIDGE_HOME)\n  --config <path>          Config file, default ./nopeek-bridge.config.json\n  -h, --help               Show this help\n\nWith no brain configured, bots run in echo mode (\"You said: \u2026\") \u2014 a zero-config smoke test.\nPairing and brains can be managed entirely from the NoPeek app once the service is running.";
+export declare const HELP = "nopeek-agent-bridge \u2014 run your agents as E2EE NoPeek bots\n\nUsage:\n  nopeek-agent-bridge install     Install as a background service (launchd/systemd),\n                                  then finish setup from the NoPeek app:\n                                  Bots -> Connect this computer.\n  nopeek-agent-bridge uninstall   Remove the background service (keeps data/settings).\n  nopeek-agent-bridge status      Show the running bridge's status.\n  nopeek-agent-bridge [run]       Run in the foreground. Unpaired bridges wait to be\n                                  paired from the NoPeek app; --pair still works:\n                                    npx @nopeek/agent-bridge --pair npr_\u2026 --app-id app_\u2026\n\nOptions:\n  --pair <code>            Pairing code from the NoPeek app             (env NOPEEK_PAIRING_CODE)\n  --app-id <id>            NoPeek app id                                (env NOPEEK_APP_ID)\n  --api-url <url>          API base, default https://d3qweh72vesa98.cloudfront.net  (env NOPEEK_API_URL)\n  --brain-cmd <cmd>        Shell brain: message on stdin -> reply on stdout   (env BRAIN_CMD)\n  --brain-url <url>        Webhook brain: POST {text,...} -> {text|reply}     (env BRAIN_URL)\n  --brain-map <json>       Per-bot overrides {\"<handle>\":{\"cmd\":\"\u2026\"}|{\"url\":\"\u2026\"}|\n                           {\"backend\":\"claude\"|\"hermes\"|\"echo\"}}              (env BRAIN_MAP)\n  --brain-provision-cmd <cmd>  Run once per new bot; stdout becomes its brain command\n                           (env BRAIN_PROVISION_CMD \u2014 e.g. a script that creates a\n                           fresh Hermes profile with its own soul + memory)\n  --app-url <url>          App opened after install                     (env NOPEEK_APP_URL)\n  --no-open                install: don't open the app in the browser\n  --brain-timeout-ms <ms>  Brain idle timeout, default 900000     (env BRAIN_TIMEOUT_MS)\n  --hermes-api-url <url>   Hermes agent API (default http://127.0.0.1:8642)  (env HERMES_API_URL)\n  --hermes-api-key <key>   Bearer for the Hermes API server                     (env HERMES_API_KEY)\n  --port <port>            Local control API port, default 8790    (env NOPEEK_BRIDGE_PORT)\n  --data-dir <dir>         Device-key store dir                        (env NOPEEK_BRIDGE_DATA_DIR)\n  --home <dir>             Bridge home, default ~/.nopeek-bridge       (env NOPEEK_BRIDGE_HOME)\n  --config <path>          Config file, default ./nopeek-bridge.config.json\n  -h, --help               Show this help\n\nWith no brain configured, bots run in echo mode (\"You said: \u2026\") \u2014 a zero-config smoke test.\nPairing and brains can be managed entirely from the NoPeek app once the service is running.";
 /** Load config from argv + env + cwd config file + home settings. Never
  *  requires pairing — an unpaired bridge waits for the app to pair it. */
 export declare function loadConfig(argv?: string[]): BridgeConfig;

package/dist/config.js

@@ -10,17 +10,17 @@ import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { parseArgs } from "node:util";
 export function isBrainBackend(v) {
-    return v === "claude" || v === "hermes" || v === "echo";
+    return v === "claude" || v === "hermes" || v === "hermes-http" || v === "echo";
 }
 export const DEFAULT_API_URL = "https://d3qweh72vesa98.cloudfront.net";
 export const DEFAULT_APP_URL = "https://d32w3to73s0pu5.cloudfront.net/messenger/";
 export const DEFAULT_PORT = 8790;
-// Idle timeout (resets on any child-process output, not a flat wall-clock cap
-// — see backends.ts). 300s of true SILENCE covers a long tool-use step (repo
-// indexing, slow provider call) on a genuinely agentic brain without needing
-// per-deployment tuning, while still killing a truly hung process reasonably
-// fast.
-export const DEFAULT_BRAIN_TIMEOUT_MS = 300_000;
+// Idle timeout (resets on any child-process output OR CPU-time advance —
+// see backends.ts). Hermes -Q often does real tool work with zero stdout for
+// many minutes; 15 min of *true* silence (no bytes AND no CPU) is the kill
+// line. A hung process that is not scheduled still dies; a working agent does not.
+export const DEFAULT_BRAIN_TIMEOUT_MS = 900_000;
+export const DEFAULT_HERMES_API_URL = "http://127.0.0.1:8642";
 export function defaultHomeDir() {
     return process.env.NOPEEK_BRIDGE_HOME || join(homedir(), ".nopeek-bridge");
 }
@@ -33,6 +33,8 @@ const CLI_OPTIONS = {
     "brain-map": { type: "string" },
     "brain-provision-cmd": { type: "string" },
     "brain-timeout-ms": { type: "string" },
+    "hermes-api-url": { type: "string" },
+    "hermes-api-key": { type: "string" },
     "decline-message": { type: "string" },
     "app-url": { type: "string" },
     "no-open": { type: "boolean" },
@@ -52,6 +54,8 @@ const FLAG_TO_KEY = {
     "brain-map": "BRAIN_MAP",
     "brain-provision-cmd": "BRAIN_PROVISION_CMD",
     "brain-timeout-ms": "BRAIN_TIMEOUT_MS",
+    "hermes-api-url": "HERMES_API_URL",
+    "hermes-api-key": "HERMES_API_KEY",
     "decline-message": "NOPEEK_DECLINE_MESSAGE",
     "app-url": "NOPEEK_APP_URL",
     port: "NOPEEK_BRIDGE_PORT",
@@ -83,7 +87,9 @@ Options:
                            fresh Hermes profile with its own soul + memory)
   --app-url <url>          App opened after install                     (env NOPEEK_APP_URL)
   --no-open                install: don't open the app in the browser
-  --brain-timeout-ms <ms>  Brain timeout, default ${DEFAULT_BRAIN_TIMEOUT_MS}          (env BRAIN_TIMEOUT_MS)
+  --brain-timeout-ms <ms>  Brain idle timeout, default ${DEFAULT_BRAIN_TIMEOUT_MS}     (env BRAIN_TIMEOUT_MS)
+  --hermes-api-url <url>   Hermes agent API (default ${DEFAULT_HERMES_API_URL})  (env HERMES_API_URL)
+  --hermes-api-key <key>   Bearer for the Hermes API server                     (env HERMES_API_KEY)
   --port <port>            Local control API port, default ${DEFAULT_PORT}    (env NOPEEK_BRIDGE_PORT)
   --data-dir <dir>         Device-key store dir                        (env NOPEEK_BRIDGE_DATA_DIR)
   --home <dir>             Bridge home, default ~/.nopeek-bridge       (env NOPEEK_BRIDGE_HOME)
@@ -132,7 +138,7 @@ function parseBrainMap(raw) {
         }
         const { cmd, url, backend, echo } = spec;
         if (backend !== undefined && !isBrainBackend(backend)) {
-            throw new Error(`BRAIN_MAP["${handle}"].backend must be "claude", "hermes" or "echo"`);
+            throw new Error(`BRAIN_MAP["${handle}"].backend must be "claude", "hermes", "hermes-http" or "echo"`);
         }
         if (typeof cmd !== "string" && typeof url !== "string" && !isBrainBackend(backend) && echo !== true) {
             throw new Error(`BRAIN_MAP["${handle}"] needs a "cmd", "url" or "backend" ("claude"|"hermes"|"echo")`);
@@ -286,6 +292,8 @@ export function loadConfig(argv = process.argv.slice(2)) {
         serverBackends: parseServerBackends(process.env.NOPEEK_SERVER_BACKENDS ?? file.NOPEEK_SERVER_BACKENDS ?? saved.NOPEEK_SERVER_BACKENDS),
         brainProvisionCmd: get("brain-provision-cmd") ?? null,
         brainTimeoutMs,
+        hermesApiUrl: (get("hermes-api-url") ?? process.env.HERMES_API_URL ?? file.HERMES_API_URL ?? saved.HERMES_API_URL ?? DEFAULT_HERMES_API_URL).replace(/\/+$/, ""),
+        hermesApiKey: get("hermes-api-key") ?? process.env.HERMES_API_KEY ?? file.HERMES_API_KEY ?? saved.HERMES_API_KEY ?? null,
         port,
         dataDir,
         homeDir,

package/dist/hermes-http.d.ts

@@ -0,0 +1,15 @@
+import type { BridgeConfig } from "./config.js";
+import { type Brain } from "./brain.js";
+export interface HermesApiHealth {
+    ok: boolean;
+    url: string;
+    reason?: string;
+    checkedAt: number;
+}
+export declare function lastHermesApiHealth(): HermesApiHealth | null;
+export declare function probeHermesApi(cfg: BridgeConfig, force?: boolean): Promise<HermesApiHealth>;
+/**
+ * Stream one turn through Hermes' OpenAI-compatible chat completions.
+ * Session continuity: X-Hermes-Session-Key = nopeek-<channelId> (stable per chat).
+ */
+export declare function hermesHttpBrain(cfg: BridgeConfig): Brain;

package/dist/hermes-http.js

@@ -0,0 +1,209 @@
+import { asHooks } from "./brain.js";
+import { RECAP_HINT } from "./tool-progress.js";
+let lastHealth = null;
+const HEALTH_TTL_MS = 15_000;
+export function lastHermesApiHealth() {
+    return lastHealth;
+}
+export async function probeHermesApi(cfg, force = false) {
+    const url = cfg.hermesApiUrl.replace(/\/+$/, "");
+    if (!force && lastHealth && Date.now() - lastHealth.checkedAt < HEALTH_TTL_MS && lastHealth.url === url) {
+        return lastHealth;
+    }
+    const headers = {};
+    if (cfg.hermesApiKey)
+        headers.authorization = `Bearer ${cfg.hermesApiKey}`;
+    try {
+        const res = await fetch(`${url}/health`, {
+            headers,
+            signal: AbortSignal.timeout(3_000),
+        });
+        lastHealth = res.ok
+            ? { ok: true, url, checkedAt: Date.now() }
+            : { ok: false, url, reason: `HTTP ${res.status}`, checkedAt: Date.now() };
+    }
+    catch (err) {
+        lastHealth = {
+            ok: false,
+            url,
+            reason: err.message || "unreachable",
+            checkedAt: Date.now(),
+        };
+    }
+    return lastHealth;
+}
+/**
+ * Stream one turn through Hermes' OpenAI-compatible chat completions.
+ * Session continuity: X-Hermes-Session-Key = nopeek-<channelId> (stable per chat).
+ */
+export function hermesHttpBrain(cfg) {
+    return async (text, ctx, hooks) => {
+        const { onChunk, onTool } = asHooks(hooks);
+        const handle = ctx.botHandle.replace(/^@/, "");
+        const tag = `[brain:hermes-http:@${handle}]`;
+        const url = cfg.hermesApiUrl.replace(/\/+$/, "");
+        const headers = {
+            "content-type": "application/json",
+        };
+        // Hermes rejects X-Hermes-Session-Key with 403 unless API_SERVER_KEY is set.
+        // Without a key, skip the header so the turn still runs (no session memory).
+        if (cfg.hermesApiKey) {
+            headers.authorization = `Bearer ${cfg.hermesApiKey}`;
+            headers["X-Hermes-Session-Key"] = `nopeek-${ctx.channelId}`;
+        }
+        // Idle abort — same rule as the CLI path. A wall-clock timeout on the
+        // whole POST would kill a healthy 20-minute agentic turn. Any SSE byte
+        // (token, keepalive, tool-progress) resets the idle timer.
+        const controller = new AbortController();
+        let idle;
+        const armIdle = () => {
+            clearTimeout(idle);
+            idle = setTimeout(() => {
+                console.error(`${tag} idle ${cfg.brainTimeoutMs / 1000}s (no SSE), aborting`);
+                controller.abort();
+            }, cfg.brainTimeoutMs);
+        };
+        armIdle();
+        let res;
+        try {
+            res = await fetch(`${url}/v1/chat/completions`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({
+                    model: "hermes-agent",
+                    stream: true,
+                    messages: [
+                        { role: "system", content: RECAP_HINT },
+                        { role: "user", content: text },
+                    ],
+                }),
+                signal: controller.signal,
+            });
+        }
+        catch (err) {
+            clearTimeout(idle);
+            console.error(`${tag} request failed: ${err.message}`);
+            return "";
+        }
+        if (!res.ok) {
+            clearTimeout(idle);
+            const body = await res.text().catch(() => "");
+            console.error(`${tag} HTTP ${res.status}: ${body.slice(0, 300)}`);
+            return "";
+        }
+        if (!res.body) {
+            clearTimeout(idle);
+            console.error(`${tag} empty body`);
+            return "";
+        }
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buf = "";
+        let reply = "";
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                armIdle();
+                buf += decoder.decode(value, { stream: true });
+                const frames = buf.split("\n\n");
+                buf = frames.pop() ?? "";
+                for (const frame of frames) {
+                    const ev = parseSseFrame(frame);
+                    if (!ev)
+                        continue;
+                    if (ev.event === "hermes.tool.progress") {
+                        const tool = asToolProgress(ev.data);
+                        if (tool)
+                            onTool?.(tool);
+                        continue;
+                    }
+                    const delta = extractDelta(ev.data);
+                    if (!delta)
+                        continue;
+                    reply += delta;
+                    onChunk?.(delta);
+                }
+            }
+            if (buf.trim()) {
+                const ev = parseSseFrame(buf);
+                if (ev?.event === "hermes.tool.progress") {
+                    const tool = asToolProgress(ev.data);
+                    if (tool)
+                        onTool?.(tool);
+                }
+                else if (ev) {
+                    const delta = extractDelta(ev.data);
+                    if (delta) {
+                        reply += delta;
+                        onChunk?.(delta);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            const msg = err.message || "";
+            if (controller.signal.aborted) {
+                return `⚠️ My brain went quiet for over ${Math.round(cfg.brainTimeoutMs / 1000)}s with no output and I had to give up on that turn — a long tool-use step or a very slow provider response can trigger this. Try messaging me again.`;
+            }
+            console.error(`${tag} stream error: ${msg}`);
+        }
+        finally {
+            clearTimeout(idle);
+        }
+        return reply.trim();
+    };
+}
+function parseSseFrame(frame) {
+    let event = "message";
+    const dataLines = [];
+    for (const raw of frame.split("\n")) {
+        const line = raw.replace(/\r$/, "");
+        if (!line || line.startsWith(":"))
+            continue;
+        if (line.startsWith("event:"))
+            event = line.slice(6).trim();
+        else if (line.startsWith("data:"))
+            dataLines.push(line.slice(5).trimStart());
+    }
+    if (dataLines.length === 0)
+        return null;
+    const payload = dataLines.join("\n");
+    if (!payload || payload === "[DONE]")
+        return null;
+    try {
+        return { event, data: JSON.parse(payload) };
+    }
+    catch {
+        return { event, data: payload };
+    }
+}
+function asToolProgress(data) {
+    if (!data || typeof data !== "object")
+        return null;
+    const obj = data;
+    const tool = typeof obj.tool === "string" ? obj.tool : typeof obj.name === "string" ? obj.name : "";
+    if (!tool)
+        return null;
+    return {
+        tool,
+        emoji: typeof obj.emoji === "string" ? obj.emoji : undefined,
+        label: typeof obj.label === "string" ? obj.label : undefined,
+        status: typeof obj.status === "string" ? obj.status : "running",
+    };
+}
+function extractDelta(parsed) {
+    if (!parsed || typeof parsed !== "object")
+        return "";
+    const obj = parsed;
+    const choice = obj.choices?.[0];
+    const fromChoice = choice?.delta?.content ?? choice?.message?.content;
+    if (typeof fromChoice === "string")
+        return fromChoice;
+    if (typeof obj.data?.content === "string")
+        return obj.data.content;
+    if (typeof obj.data?.text === "string")
+        return obj.data.text;
+    return "";
+}

package/dist/last-turn.d.ts

@@ -0,0 +1,22 @@
+export interface BrainTurn {
+    handle: string;
+    channelId: string;
+    via: string;
+    startedAt: number;
+    endedAt: number | null;
+    inFlight: boolean;
+    ok: boolean | null;
+    chars: number;
+    timedOut: boolean;
+    error: string | null;
+}
+export declare function beginTurn(handle: string, channelId: string, via: string): BrainTurn;
+export declare function finishTurn(t: BrainTurn, result: {
+    ok: boolean;
+    chars?: number;
+    timedOut?: boolean;
+    error?: string | null;
+}): void;
+export declare function lastTurnFor(handle: string): BrainTurn | null;
+export declare function lastTurnGlobal(): BrainTurn | null;
+export declare function turnSnapshot(t: BrainTurn | null): Record<string, unknown> | null;

package/dist/last-turn.js

@@ -0,0 +1,50 @@
+const byHandle = new Map();
+let global = null;
+export function beginTurn(handle, channelId, via) {
+    const t = {
+        handle: handle.replace(/^@/, ""),
+        channelId,
+        via,
+        startedAt: Date.now(),
+        endedAt: null,
+        inFlight: true,
+        ok: null,
+        chars: 0,
+        timedOut: false,
+        error: null,
+    };
+    byHandle.set(t.handle, t);
+    global = t;
+    return t;
+}
+export function finishTurn(t, result) {
+    t.endedAt = Date.now();
+    t.inFlight = false;
+    t.ok = result.ok;
+    t.chars = result.chars ?? 0;
+    t.timedOut = result.timedOut === true;
+    t.error = result.error ?? null;
+}
+export function lastTurnFor(handle) {
+    return byHandle.get(handle.replace(/^@/, "")) ?? null;
+}
+export function lastTurnGlobal() {
+    return global;
+}
+export function turnSnapshot(t) {
+    if (!t)
+        return null;
+    return {
+        handle: t.handle,
+        channelId: t.channelId,
+        via: t.via,
+        startedAt: t.startedAt,
+        endedAt: t.endedAt,
+        ms: t.endedAt != null ? t.endedAt - t.startedAt : Date.now() - t.startedAt,
+        inFlight: t.inFlight,
+        ok: t.ok,
+        chars: t.chars,
+        timedOut: t.timedOut,
+        error: t.error,
+    };
+}

package/dist/localapi.js

@@ -164,7 +164,7 @@ async function handle(app, req, res) {
         return;
     }
     if (method === "GET" && path === "/status") {
-        json(res, 200, app.statusFull(auth.runtimeId));
+        json(res, 200, await app.statusFull(auth.runtimeId));
         return;
     }
     if (method === "GET" && path === "/detect") {
@@ -181,7 +181,7 @@ async function handle(app, req, res) {
             return;
         }
         app.setBrains(body);
-        json(res, 200, { ok: true, status: app.statusFull(auth.runtimeId) });
+        json(res, 200, { ok: true, status: await app.statusFull(auth.runtimeId) });
         return;
     }
     // ?runtimeId=rt_… removes ONE account's pairing; no query = remove ALL

package/dist/service.d.ts

@@ -1,15 +1,4 @@
 import type { BridgeConfig } from "./config.js";
-/**
- * Periodic self-update: compares the running version against npm's published
- * `latest` and, if newer, re-installs using the SAME method this process is
- * actually running from (global npm root, or the private <home>/app copy —
- * see resolveEntrypoint above) and exits so the always-restart service
- * relaunches running the fresh code. Only acts on an install method it
- * recognizes — a pnpm-linked dev checkout or anything unrecognized is left
- * alone (safety over completeness). This is how a published fix (like a
- * reconnect-reliability bug) actually reaches already-installed bridges
- * instead of sitting unused until someone manually reinstalls.
- */
 export declare function checkForUpdate(currentVersion: string, homeDir: string): Promise<void>;
 export declare function installService(cfg: BridgeConfig, noOpen?: boolean): Promise<void>;
 export declare function uninstallService(): void;

package/dist/service.js

@@ -43,7 +43,21 @@ function resolveEntrypoint(homeDir) {
  * reconnect-reliability bug) actually reaches already-installed bridges
  * instead of sitting unused until someone manually reinstalls.
  */
+function isNewerVersion(latest, current) {
+    const a = latest.split(".").map((n) => Number.parseInt(n, 10) || 0);
+    const b = current.split(".").map((n) => Number.parseInt(n, 10) || 0);
+    const n = Math.max(a.length, b.length);
+    for (let i = 0; i < n; i++) {
+        if ((a[i] ?? 0) > (b[i] ?? 0))
+            return true;
+        if ((a[i] ?? 0) < (b[i] ?? 0))
+            return false;
+    }
+    return false;
+}
 export async function checkForUpdate(currentVersion, homeDir) {
+    if (process.env.NOPEEK_BRIDGE_NO_AUTO_UPDATE === "1")
+        return;
     let latest;
     try {
         const res = await fetch("https://registry.npmjs.org/@nopeek/agent-bridge/latest", {
@@ -57,7 +71,10 @@ export async function checkForUpdate(currentVersion, homeDir) {
     catch {
         return; // offline / registry unreachable — try again next check
     }
-    if (!latest || latest === currentVersion)
+    // Only UPGRADE. A local/unpublished build (0.7.10) must never be replaced
+    // by an older published latest (0.7.8) — that exact downgrade put the 300s
+    // idle kill back on this machine after we installed the fix.
+    if (!latest || !isNewerVersion(latest, currentVersion))
         return;
     const self = realpathSync(process.argv[1]);
     let installArgs = null;
@@ -123,6 +140,7 @@ export async function installService(cfg, noOpen = false) {
   <key>EnvironmentVariables</key>
   <dict>
     <key>NOPEEK_BRIDGE_HOME</key><string>${xmlEscape(cfg.homeDir)}</string>
+    <key>NOPEEK_BRIDGE_NO_AUTO_UPDATE</key><string>${xmlEscape(process.env.NOPEEK_BRIDGE_NO_AUTO_UPDATE ?? "0")}</string>
     <key>PATH</key><string>${xmlEscape(process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin")}</string>
   </dict>
   <key>RunAtLoad</key><true/>

package/dist/tool-progress.d.ts

@@ -0,0 +1,29 @@
+export type ToolProgressEvent = {
+    tool: string;
+    emoji?: string;
+    label?: string;
+    status?: string;
+};
+/** One Telegram-style line. Running events only; completed is silent. */
+export declare function formatToolLine(ev: ToolProgressEvent): string | null;
+export type ProgressSender = (text: string) => Promise<void>;
+/**
+ * Collect tool lines and flush them as short chat messages.
+ * Flush when we have `maxLines` tools, or after `gapMs` of quiet.
+ */
+export declare class ToolProgressFlusher {
+    private readonly send;
+    private readonly gapMs;
+    private readonly maxLines;
+    private lines;
+    private timer;
+    private chain;
+    private seen;
+    constructor(send: ProgressSender, gapMs?: number, maxLines?: number);
+    get pending(): number;
+    push(ev: ToolProgressEvent): void;
+    flush(): Promise<void>;
+    private arm;
+}
+/** Hint so Hermes ends a tool-using turn with a recap, like Telegram. */
+export declare const RECAP_HINT = "When this turn used tools (read/write files, commands, skills, memory), end your reply with a short recap: what was going on, what you did, and the result. Skip the recap for simple chat with no tools. No em dashes.";

package/dist/tool-progress.js

@@ -0,0 +1,105 @@
+// Telegram-style tool progress for NoPeek bots.
+//
+// Hermes emits `hermes.tool.progress` SSE events while it works. Telegram
+// already shows those as short status messages (a few tools, then a new
+// message after a quiet gap). We do the same in the encrypted chat so the
+// human can see the bot is actually taking action.
+const FALLBACK_EMOJI = {
+    read_file: "📖",
+    write_file: "✍️",
+    patch: "🔧",
+    search_files: "🔎",
+    terminal: "💻",
+    web_search: "🔍",
+    web_extract: "📄",
+    web_crawl: "🕸️",
+    memory: "🧠",
+    skill_view: "📘",
+    skill_manage: "🧩",
+    skills_list: "📚",
+    todo: "✅",
+    execute_code: "🐍",
+    delegate_task: "👥",
+    cronjob: "⏰",
+    process: "⚙️",
+};
+/** One Telegram-style line. Running events only; completed is silent. */
+export function formatToolLine(ev) {
+    if (ev.status && ev.status !== "running")
+        return null;
+    const tool = (ev.tool || "").trim();
+    if (!tool || tool.startsWith("_"))
+        return null;
+    const emoji = (ev.emoji || FALLBACK_EMOJI[tool] || "⚡").trim() || "⚡";
+    const label = tidyLabel(ev.label);
+    if (label)
+        return `${emoji} ${tool}: "${label}"`;
+    return `${emoji} ${tool}...`;
+}
+function tidyLabel(raw) {
+    if (!raw)
+        return "";
+    const s = raw.replace(/\s+/g, " ").trim();
+    if (!s)
+        return "";
+    return s.length > 80 ? `${s.slice(0, 77)}...` : s;
+}
+/**
+ * Collect tool lines and flush them as short chat messages.
+ * Flush when we have `maxLines` tools, or after `gapMs` of quiet.
+ */
+export class ToolProgressFlusher {
+    send;
+    gapMs;
+    maxLines;
+    lines = [];
+    timer = null;
+    chain = Promise.resolve();
+    seen = new Set();
+    constructor(send, gapMs = 2200, maxLines = 4) {
+        this.send = send;
+        this.gapMs = gapMs;
+        this.maxLines = maxLines;
+    }
+    get pending() {
+        return this.lines.length;
+    }
+    push(ev) {
+        const line = formatToolLine(ev);
+        if (!line)
+            return;
+        if (this.lines[this.lines.length - 1] === line)
+            return;
+        if (this.seen.has(line) && this.lines.includes(line))
+            return;
+        this.seen.add(line);
+        this.lines.push(line);
+        if (this.lines.length >= this.maxLines) {
+            void this.flush();
+            return;
+        }
+        this.arm();
+    }
+    async flush() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        if (this.lines.length === 0)
+            return;
+        const text = this.lines.join("\n");
+        this.lines = [];
+        this.chain = this.chain.then(() => this.send(text).catch(() => { }));
+        await this.chain;
+    }
+    arm() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            void this.flush();
+        }, this.gapMs);
+    }
+}
+/** Hint so Hermes ends a tool-using turn with a recap, like Telegram. */
+export const RECAP_HINT = "When this turn used tools (read/write files, commands, skills, memory), end your reply with a short recap: what was going on, what you did, and the result. Skip the recap for simple chat with no tools. No em dashes.";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nopeek/agent-bridge",
-  "version": "0.7.8",
+  "version": "0.7.11",
   "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",
@@ -22,8 +22,15 @@
   "engines": {
     "node": ">=22"
   },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepack": "tsc -p tsconfig.json",
+    "start": "node dist/cli.js",
+    "dev": "tsx src/cli.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
   "dependencies": {
-    "@nopeek/chat": "^0.2.4"
+    "@nopeek/chat": "workspace:^0.2.4"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",
@@ -40,11 +47,5 @@
   ],
   "publishConfig": {
     "access": "public"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "start": "node dist/cli.js",
-    "dev": "tsx src/cli.ts",
-    "typecheck": "tsc -p tsconfig.json --noEmit"
   }
-}
+}