@nopeek/agent-bridge 0.7.16 → 0.7.18

package/dist/backends.js

@@ -25,8 +25,7 @@ const SOUL_TEMPLATE = `You are {{NAME}} (handle @{{HANDLE}}), a personal AI agen
 NoPeek end-to-end-encrypted messenger. A human messages you in a chat; you help;
 you reply. Everything you output is sent verbatim as a chat message.
 
-Voice: friendly, sharp, concise. This is a chat, not a report — short paragraphs
-or brief lists, no markdown headers. Answer the question directly.
+Voice: friendly, sharp, concise. This is a chat, not a report. Telegram markdown is ok (**bold**, lists, inline code, fenced copy blocks). Answer the question directly.
 
 You have your own memory of past conversations in this chat (each chat is a
 separate ongoing thread). Remember what the humans tell you.
@@ -293,7 +292,7 @@ you reply. Your replies are chat messages — every word you print is sent verba
 
 ## Voice
 - Friendly, sharp, practical. Concise by default — this is a chat, not a report.
-- Plain language. No markdown headers in replies; short paragraphs or brief lists only.
+- Plain language. Telegram markdown is ok: **bold** labels, lists, inline code, and fenced copy blocks. No # headers.
 
 ## Memory
 - This profile is yours alone: your soul (this file) and your memories

package/dist/tool-progress.d.ts

@@ -7,7 +7,9 @@ export type ToolProgressEvent = {
 /** One Telegram-style line. Running events only; completed is silent. */
 export declare function formatToolLine(ev: ToolProgressEvent): string | null;
 /** 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.";
+export declare const RECAP_HINT = "When this turn used tools, your LAST message must be ONE phone briefing (not split). Use **bold** labels and blank lines like Telegram: **What was wrong**, **What I did**, **Current state**. Put copyable commands in ``` fences. Never end on a tool list, a diff, or \"tasks completed\". Skip the briefing only for simple chat with no tools. No em dashes.";
+/** Posted when tools ran but the model never wrote a human recap. */
+export declare const MISSING_BRIEFING = "Done. I finished that work. Ask if you want the recap: what was wrong, what I did, and where things stand.";
 export interface StreamHandle {
     append(chunk: string): void;
     replace(full: string): void;
@@ -35,6 +37,8 @@ export type TurnFinishKind = "streamed" | "sent" | "empty";
 export declare function unpublishedTail(full: string, published: string): string;
 /** Unified diffs / `| review` dumps should never land in the chat. */
 export declare function isDumpLine(line: string): boolean;
+/** True when the text has a user-readable recap, not just tools/dumps. */
+export declare function isHumanBriefing(text: string): boolean;
 export declare function isToolDump(text: string): boolean;
 /** Drop dump lines from a live chunk without swallowing normal punctuation. */
 export declare function stripDumps(text: string): string;
@@ -74,10 +78,12 @@ export declare class TurnPublisher {
     /** After `bubbleGapMs` of silence, seal the current bubble. Next text is new. */
     private armGap;
     private enqueue;
-    /** Open or append the current commentary/answer stream with this chunk only. */
+    /** After tools start, hold prose until finish() so the briefing is one bubble. */
     private appendCommentary;
     /** Finalize the current commentary so later tools land below it. */
     private commitText;
+    /** Final recap stays one Telegram-style bubble. Dumps still dropped. */
+    private sendBriefing;
     private sendBubbles;
     private addProgressLine;
     private closeProgress;

package/dist/tool-progress.js

@@ -49,7 +49,9 @@ function tidyLabel(raw) {
     return s.length > 80 ? `${s.slice(0, 77)}...` : s;
 }
 /** 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.";
+export const RECAP_HINT = "When this turn used tools, your LAST message must be ONE phone briefing (not split). Use **bold** labels and blank lines like Telegram: **What was wrong**, **What I did**, **Current state**. Put copyable commands in ``` fences. Never end on a tool list, a diff, or \"tasks completed\". Skip the briefing only for simple chat with no tools. No em dashes.";
+/** Posted when tools ran but the model never wrote a human recap. */
+export const MISSING_BRIEFING = "Done. I finished that work. Ask if you want the recap: what was wrong, what I did, and where things stand.";
 /** Text in `full` that has not already been posted as commentary. */
 export function unpublishedTail(full, published) {
     const f = full.trim();
@@ -95,8 +97,37 @@ export function isDumpLine(line) {
         return true;
     if (/^index [0-9a-f]+\.\.[0-9a-f]+/.test(l))
         return true;
+    // Unified-diff / review lines: "+    const x =" not "+1 country".
+    if (/^[+-]\s{2,}\S/.test(l))
+        return true;
+    if (/^[+-][A-Za-z_]/.test(l))
+        return true;
+    if (/^[+-]\s*(import |from |export |const |let |function |class |def |if cmd\b|return )/.test(l))
+        return true;
+    if (/^[+-]\s*["'`{]/.test(l))
+        return true;
     return false;
 }
+function isToolProgressLine(line) {
+    const l = line.trim();
+    if (!l)
+        return false;
+    return /^.+ \S+: ".+"$/.test(l) || /^.+ \S+\.\.\.$/.test(l);
+}
+/** True when the text has a user-readable recap, not just tools/dumps. */
+export function isHumanBriefing(text) {
+    const prose = text
+        .split("\n")
+        .filter((l) => {
+        const t = l.trim();
+        return Boolean(t) && !isDumpLine(t) && !isToolProgressLine(t);
+    })
+        .join("\n")
+        .trim();
+    if (!prose || isToolDump(prose))
+        return false;
+    return true;
+}
 export function isToolDump(text) {
     const t = text.trim();
     if (!t)
@@ -119,8 +150,6 @@ export function stripDumps(text) {
         return text;
     if (!text.includes("\n"))
         return isDumpLine(text) ? "" : text;
-    if (isToolDump(text))
-        return "";
     return text
         .split("\n")
         .filter((l) => !isDumpLine(l))
@@ -246,13 +275,16 @@ export class TurnPublisher {
         if (this.seen.has(line) && this.progressLines.includes(line))
             return;
         this.seen.add(line);
+        const firstTool = !this.toolsUsed;
         this.toolsUsed = true;
         this.cancelStart();
         this.cancelGap();
         this.enqueue(async () => {
-            const pending = this.held;
-            this.held = "";
-            await this.commitText(pending);
+            if (firstTool) {
+                const pending = this.held;
+                this.held = "";
+                await this.commitText(pending);
+            }
             await this.addProgressLine(line);
         });
     }
@@ -261,14 +293,24 @@ export class TurnPublisher {
         this.cancelGap();
         await this.write;
         await this.closeProgress();
-        await this.commitText(this.held);
+        const pending = this.held;
         this.held = "";
+        if (!this.toolsUsed) {
+            await this.commitText(pending);
+        }
         const rest = unpublishedTail(reply.trim(), this.published);
-        if (!rest)
-            return this.published.trim() ? "streamed" : "empty";
-        this.opts.stopTyping();
-        const sent = await this.sendBubbles(rest);
-        return sent ? "sent" : this.published.trim() ? "streamed" : "empty";
+        const briefing = rest || (this.toolsUsed ? pending.trim() : "");
+        if (briefing) {
+            this.opts.stopTyping();
+            await this.sendBriefing(briefing);
+        }
+        if (this.toolsUsed && reply.trim() && !isHumanBriefing(this.published)) {
+            this.opts.stopTyping();
+            await this.sendBriefing(MISSING_BRIEFING);
+        }
+        if (!this.published.trim())
+            return "empty";
+        return rest || this.toolsUsed ? "sent" : "streamed";
     }
     async fail(text) {
         this.cancelStart();
@@ -319,26 +361,13 @@ export class TurnPublisher {
             console.error(`[turn] ${err.message}`);
         });
     }
-    /** Open or append the current commentary/answer stream with this chunk only. */
+    /** After tools start, hold prose until finish() so the briefing is one bubble. */
     async appendCommentary(chunk) {
         if (!chunk)
             return;
         if (this.toolsUsed) {
             await this.closeProgress();
             this.held += chunk;
-            const cut = this.held.lastIndexOf("\n\n");
-            if (cut >= 0) {
-                const ready = this.held.slice(0, cut);
-                this.held = this.held.slice(cut + 2);
-                this.opts.stopTyping();
-                await this.sendBubbles(ready);
-            }
-            else if (this.held.length >= this.maxBubbleChars) {
-                const ready = this.held;
-                this.held = "";
-                this.opts.stopTyping();
-                await this.sendBubbles(ready);
-            }
             return;
         }
         this.opts.stopTyping();
@@ -382,7 +411,11 @@ export class TurnPublisher {
                 if (extra)
                     s.append(extra);
                 const parts = splitBubbles(final, this.maxBubbleChars);
-                const first = parts[0] || final;
+                if (!parts.length) {
+                    await s.done("…").catch(() => { });
+                    return;
+                }
+                const first = parts[0];
                 await s.done(first).catch(() => { });
                 this.published += first;
                 for (const more of parts.slice(1)) {
@@ -403,6 +436,15 @@ export class TurnPublisher {
         this.opts.stopTyping();
         await this.sendBubbles(pending);
     }
+    /** Final recap stays one Telegram-style bubble. Dumps still dropped. */
+    async sendBriefing(text) {
+        const cleaned = stripDumps(text.replace(/\r\n/g, "\n")).trim();
+        if (!cleaned || isToolDump(cleaned))
+            return false;
+        await this.sink.send(cleaned);
+        this.published += this.published ? `\n\n${cleaned}` : cleaned;
+        return true;
+    }
     async sendBubbles(text) {
         const parts = splitBubbles(text, this.maxBubbleChars);
         if (!parts.length)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nopeek/agent-bridge",
-  "version": "0.7.16",
+  "version": "0.7.18",
   "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",