@canonmsg/codex-plugin 0.19.0 → 0.19.1

package/dist/app-server-adapter.d.ts

@@ -84,6 +84,13 @@ export declare class CodexAppServerAdapter {
     private handleLine;
     private handleServerRequest;
     private handleNotification;
+    /**
+     * The turn's final message is the JOIN of every agentMessage item, in
+     * insertion order — not just the last item. The streamed turn trail folds
+     * all items (one text segment per item), so the final text must match the
+     * streamed/folded text or the app renders the turn twice.
+     */
+    private joinedAgentMessageText;
     private isCurrentThreadNotification;
     private resolveCurrentTurn;
     private clearActiveTurn;

package/dist/app-server-adapter.js

@@ -393,7 +393,7 @@ export class CodexAppServerAdapter {
             const delta = readRawString(params, 'delta') ?? '';
             const next = `${this.messageTextByItem.get(itemId) ?? ''}${delta}`;
             this.messageTextByItem.set(itemId, next);
-            this.currentFinalMessage = next.trim() ? next : this.currentFinalMessage;
+            this.currentFinalMessage = this.joinedAgentMessageText() ?? this.currentFinalMessage;
             if (next.trim())
                 this.currentOnEvent?.({ type: 'message', text: next, itemId });
             return;
@@ -432,7 +432,8 @@ export class CodexAppServerAdapter {
                 const itemId = readString(item, 'id');
                 const text = readString(item, 'text');
                 if (text) {
-                    this.currentFinalMessage = text;
+                    this.messageTextByItem.set(itemId ?? 'agent-message', text);
+                    this.currentFinalMessage = this.joinedAgentMessageText() ?? text;
                     this.currentOnEvent?.({
                         type: 'message',
                         text,
@@ -486,6 +487,18 @@ export class CodexAppServerAdapter {
             this.currentErrorText = stringifyPreview(params);
         }
     }
+    /**
+     * The turn's final message is the JOIN of every agentMessage item, in
+     * insertion order — not just the last item. The streamed turn trail folds
+     * all items (one text segment per item), so the final text must match the
+     * streamed/folded text or the app renders the turn twice.
+     */
+    joinedAgentMessageText() {
+        const joined = [...this.messageTextByItem.values()]
+            .filter((text) => text.trim())
+            .join('\n\n');
+        return joined.trim() ? joined : null;
+    }
     isCurrentThreadNotification(params) {
         const threadId = readNotificationThreadId(params);
         if (threadId && this.threadId && threadId !== this.threadId)

package/dist/host.js

@@ -26,7 +26,7 @@ import { detectCodexCliVersion } from './codex-cli-version.js';
 import { buildCodexModelGuardMessage, formatCodexTurnFailure, isRecoverableCodexThreadError, } from './error-format.js';
 import { attachCodexControlNotifications } from './control-channel.js';
 import { runCli } from './cli-entry.js';
-import { beginCommandBlock, claimCommandBlock, createCommandBlockTracker, textSegmentBlockId, } from './turn-activity.js';
+import { beginCommandBlock, claimCommandBlock, createCommandBlockTracker, hasSpeechSegmentText, textSegmentBlockId, } from './turn-activity.js';
 const HELP = `canon-codex — run a local Codex agent host for Canon
 
 USAGE
@@ -990,7 +990,16 @@ export async function main() {
                                     title: 'Plan',
                                     text: event.text,
                                 });
-                                writers.streamingOutput.replaceSnapshot(event.text, 'streaming').catch(() => { });
+                                if (hasSpeechSegmentText(writers.streamingOutput.getBlocks())) {
+                                    // Speech is already flowing: publish the staged plan block
+                                    // only. Replacing the whole snapshot with plan text would be
+                                    // undone by the next agentMessage snapshot and make the
+                                    // smoothed bubble snap back and forth.
+                                    writers.streamingOutput.flush().catch(() => { });
+                                }
+                                else {
+                                    writers.streamingOutput.replaceSnapshot(event.text, 'streaming').catch(() => { });
+                                }
                                 return;
                             }
                             if (event.type === 'waiting') {
@@ -1001,9 +1010,6 @@ export async function main() {
                                 return;
                             }
                             if (event.type === 'command.started') {
-                                session.turnState = 'tool';
-                                writers.writeTurn();
-                                writers.startVisibleWorkSignal();
                                 const blockId = beginCommandBlock(session.turnCommandBlocks, {
                                     turnId: session.currentTurnId,
                                     command: event.command,
@@ -1016,6 +1022,16 @@ export async function main() {
                                     title: summarizeCommand(event.command),
                                     summary: 'Command running',
                                 });
+                                if (hasSpeechSegmentText(writers.streamingOutput.getBlocks())) {
+                                    // Speech is already flowing: the staged tool block narrates
+                                    // the command in the margin. Publish it without flapping the
+                                    // bubble status away from 'streaming'.
+                                    writers.streamingOutput.flush().catch(() => { });
+                                    return;
+                                }
+                                session.turnState = 'tool';
+                                writers.writeTurn();
+                                writers.startVisibleWorkSignal();
                                 writers.streamingOutput.setStatus('tool').catch(() => { });
                                 return;
                             }
@@ -1034,12 +1050,18 @@ export async function main() {
                                         summary: 'Command completed',
                                     });
                                 }
-                                if (session.turnState === 'tool') {
+                                if (session.turnState === 'tool'
+                                    && !hasSpeechSegmentText(writers.streamingOutput.getBlocks())) {
                                     session.turnState = 'thinking';
                                     writers.writeTurn();
                                     writers.startVisibleWorkSignal();
                                     writers.streamingOutput.setStatus('thinking').catch(() => { });
                                 }
+                                else {
+                                    // Speech is flowing (or the turn never left streaming):
+                                    // publish the staged completion without a status flap.
+                                    writers.streamingOutput.flush().catch(() => { });
+                                }
                                 return;
                             }
                             if (event.type === 'turn.completed') {

package/dist/turn-activity.d.ts

@@ -1,8 +1,17 @@
+import type { TurnOutputBlock } from '@canonmsg/core/contract';
 interface RunningCommandBlock {
     command: string;
     blockId: string;
     itemId?: string;
 }
+/**
+ * True once the streaming output already carries assistant speech (folded
+ * text segments). While speech is flowing the host must not flap the bubble
+ * status to tool/thinking or clobber the live text with plan snapshots — the
+ * staged margin blocks already narrate that activity, and every status/text
+ * swap makes the smoothed bubble snap.
+ */
+export declare function hasSpeechSegmentText(blocks: ReadonlyArray<Pick<TurnOutputBlock, 'kind' | 'text'>>): boolean;
 export interface CommandBlockTracker {
     sequence: number;
     running: RunningCommandBlock[];

package/dist/turn-activity.js

@@ -1,3 +1,13 @@
+/**
+ * True once the streaming output already carries assistant speech (folded
+ * text segments). While speech is flowing the host must not flap the bubble
+ * status to tool/thinking or clobber the live text with plan snapshots — the
+ * staged margin blocks already narrate that activity, and every status/text
+ * swap makes the smoothed bubble snap.
+ */
+export function hasSpeechSegmentText(blocks) {
+    return blocks.some((block) => block.kind === 'text' && Boolean(block.text?.trim()));
+}
 export function createCommandBlockTracker() {
     return {
         sequence: 0,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.19.0",
+  "version": "0.19.1",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/index.js",
@@ -31,10 +31,10 @@
   "dependencies": {
     "@canonmsg/agent-host": "^0.3.0",
     "@canonmsg/agent-sdk": "^3.4.3",
-    "@canonmsg/backend-contracts": "^1.8.0",
-    "@canonmsg/bridge": "^0.2.0",
-    "@canonmsg/core": "^3.1.0",
-    "@canonmsg/framework": "^0.2.0"
+    "@canonmsg/backend-contracts": "^1.8.1",
+    "@canonmsg/bridge": "^0.2.1",
+    "@canonmsg/core": "^3.1.1",
+    "@canonmsg/framework": "^0.2.1"
   },
   "engines": {
     "node": ">=18.0.0"