@canonmsg/codex-plugin 0.19.0 → 0.19.2

package/dist/adapter.d.ts

@@ -8,6 +8,7 @@ export type CodexEvent = {
 } | {
     type: 'message';
     text: string;
+    delta?: string;
     itemId?: string;
 } | {
     type: 'plan.updated';

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

@@ -39,6 +39,7 @@ export declare class CodexAppServerAdapter {
     private skillsCache;
     private messageTextByItem;
     private planText;
+    private traceTurnEpochMs;
     constructor(opts: {
         cwd: string;
         threadId?: string | null;
@@ -84,9 +85,18 @@ 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;
     private sendRequest;
     private write;
+    private trace;
+    private traceLine;
 }

package/dist/app-server-adapter.js

@@ -31,6 +31,7 @@ export class CodexAppServerAdapter {
     skillsCache = null;
     messageTextByItem = new Map();
     planText = '';
+    traceTurnEpochMs = null;
     constructor(opts) {
         this.cwd = opts.cwd;
         this.threadId = opts.threadId ?? null;
@@ -117,6 +118,8 @@ export class CodexAppServerAdapter {
         this.interrupted = false;
         this.messageTextByItem.clear();
         this.planText = '';
+        this.traceTurnEpochMs = Date.now();
+        this.trace('turn/run begin');
         try {
             if (this.threadId && this.loadedThreadId !== this.threadId) {
                 const resumed = await this.sendRequest('thread/resume', {
@@ -158,9 +161,11 @@ export class CodexAppServerAdapter {
                 this.currentTurnReject = reject;
             });
             turnPromise.catch(() => { });
+            const turnInput = await this.buildTurnInput(prompt, imagePaths);
+            this.trace('turn/start sent');
             const turnStarted = await this.sendRequest('turn/start', {
                 threadId: this.threadId,
-                input: await this.buildTurnInput(prompt, imagePaths),
+                input: turnInput,
                 ...(this.model ? { model: this.model } : {}),
                 ...this.sandboxPolicyPayload(_extraAddDirs),
                 collaborationMode: {
@@ -172,6 +177,7 @@ export class CodexAppServerAdapter {
                     },
                 },
             });
+            this.trace('turn/start ack');
             const turn = turnStarted.turn;
             if (this.currentTurnResolve) {
                 this.currentTurnId = readString(turn, 'id') ?? null;
@@ -322,6 +328,7 @@ export class CodexAppServerAdapter {
         const message = parseJson(line);
         if (!message)
             return;
+        this.traceLine(line, message);
         if ('id' in message && ('result' in message || 'error' in message) && !('method' in message)) {
             const id = Number(message.id);
             const pending = this.pending.get(id);
@@ -393,9 +400,9 @@ 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 });
+                this.currentOnEvent?.({ type: 'message', text: next, delta, itemId });
             return;
         }
         if (method === 'turn/plan/updated') {
@@ -432,7 +439,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,
@@ -466,6 +474,7 @@ export class CodexAppServerAdapter {
             return;
         }
         if (method === 'turn/completed') {
+            this.trace('turn/completed notification');
             const turn = params.turn;
             const status = turn?.status;
             if (isRecord(status) && status.type === 'failed') {
@@ -486,6 +495,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)
@@ -517,6 +538,7 @@ export class CodexAppServerAdapter {
         this.currentErrorText = null;
         this.messageTextByItem.clear();
         this.planText = '';
+        this.traceTurnEpochMs = null;
     }
     sendRequest(method, params) {
         const id = this.requestSeq++;
@@ -536,6 +558,33 @@ export class CodexAppServerAdapter {
             throw new Error('Codex app-server is not running');
         this.child.stdin.write(`${JSON.stringify(message)}\n`);
     }
+    trace(message) {
+        if (!isCodexTraceEnabled())
+            return;
+        const elapsedMs = this.traceTurnEpochMs === null ? 0 : Date.now() - this.traceTurnEpochMs;
+        console.error(`[canon-codex-trace] +${elapsedMs}ms ${message}`);
+    }
+    traceLine(line, message) {
+        if (!isCodexTraceEnabled())
+            return;
+        const method = typeof message.method === 'string' ? message.method : null;
+        if (!method) {
+            const id = 'id' in message ? ` id=${String(message.id)}` : '';
+            this.trace(`line bytes=${line.length} response${id}`);
+            return;
+        }
+        if (method === 'item/agentMessage/delta') {
+            const params = isRecord(message.params) ? message.params : {};
+            const itemId = readString(params, 'itemId') ?? 'agent-message';
+            const delta = readRawString(params, 'delta') ?? '';
+            this.trace(`line bytes=${line.length} method=${method} itemId=${itemId} deltaLen=${delta.length}`);
+            return;
+        }
+        this.trace(`line bytes=${line.length} method=${method}`);
+    }
+}
+function isCodexTraceEnabled() {
+    return process.env.CANON_CODEX_TRACE_EVENTS === '1';
 }
 function parseJson(line) {
     try {

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, applyCodexMessageToStreamingOutput, claimCommandBlock, createCommandBlockTracker, hasSpeechSegmentText, } from './turn-activity.js';
 const HELP = `canon-codex — run a local Codex agent host for Canon
 
 USAGE
@@ -108,6 +108,35 @@ const CODEX_RUNTIME_CAPABILITIES = {
     supportsQueue: true,
     supportsNonFinalPermanentMessages: false,
 };
+function isCodexTraceEnabled() {
+    return process.env.CANON_CODEX_TRACE_EVENTS === '1';
+}
+function createCodexTracePort(port) {
+    if (!isCodexTraceEnabled())
+        return port;
+    return new Proxy(port, {
+        get(target, property, receiver) {
+            if (property !== 'publishStreaming') {
+                return Reflect.get(target, property, receiver);
+            }
+            return async (input) => {
+                const startedAt = Date.now();
+                const textLength = typeof input.text === 'string' ? input.text.length : 0;
+                console.error(`[canon-codex-trace] publishStreaming sent conversation=${input.conversationId} turn=${input.turnId ?? input.messageId ?? 'unknown'} textLen=${textLength}`);
+                try {
+                    const result = await target.publishStreaming(input);
+                    console.error(`[canon-codex-trace] publishStreaming ack conversation=${input.conversationId} ackMs=${Date.now() - startedAt}`);
+                    return result;
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    console.error(`[canon-codex-trace] publishStreaming error conversation=${input.conversationId} ackMs=${Date.now() - startedAt} error=${message}`);
+                    throw error;
+                }
+            };
+        },
+    });
+}
 // This host process resolves and locks exactly one agent profile. The lock
 // handle returned by resolveCanonAgent is held here so the top-level runCli
 // error handler (outside main's scope) can release it on a failed start —
@@ -554,7 +583,7 @@ export async function main() {
     });
     // The BridgeClient's zod-derived result shapes mirror the core wire types
     // structurally; the port pins the strong types the host machinery uses.
-    const port = bridge.client;
+    const port = createCodexTracePort(bridge.client);
     bridge.client.onProtocolError((error) => {
         console.error(`[canon-codex] Bridge protocol error: ${error.message}`);
     });
@@ -976,7 +1005,12 @@ export async function main() {
                                 session.turnState = 'streaming';
                                 writers.writeTurn();
                                 writers.stopVisibleWorkSignal();
-                                writers.streamingOutput.replaceTextSegmentSnapshot(textSegmentBlockId(session.currentTurnId, event.itemId), event.text);
+                                applyCodexMessageToStreamingOutput(writers.streamingOutput, {
+                                    turnId: session.currentTurnId,
+                                    itemId: event.itemId,
+                                    text: event.text,
+                                    delta: event.delta,
+                                });
                                 return;
                             }
                             if (event.type === 'plan.updated') {
@@ -990,7 +1024,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 +1044,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 +1056,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 +1084,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[];
@@ -15,6 +24,16 @@ export declare function createCommandBlockTracker(): CommandBlockTracker;
  * only owns the codex id scheme.
  */
 export declare function textSegmentBlockId(turnId: string | null | undefined, itemId?: string): string;
+export interface CodexTextSegmentOutput {
+    appendTextSegmentDelta(id: string, delta: string): void;
+    replaceTextSegmentSnapshot(id: string, text: string): void;
+}
+export declare function applyCodexMessageToStreamingOutput(output: CodexTextSegmentOutput, input: {
+    turnId: string | null | undefined;
+    itemId?: string;
+    text: string;
+    delta?: string;
+}): void;
 export declare function beginCommandBlock(tracker: CommandBlockTracker, input: {
     turnId: string | null | undefined;
     command: string;

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,
@@ -17,6 +27,14 @@ function normalizeOptionalString(value) {
 export function textSegmentBlockId(turnId, itemId) {
     return `message:${turnId ?? 'turn'}:${normalizeOptionalString(itemId) ?? 'latest'}`;
 }
+export function applyCodexMessageToStreamingOutput(output, input) {
+    const segmentId = textSegmentBlockId(input.turnId, input.itemId);
+    if (input.delta !== undefined) {
+        output.appendTextSegmentDelta(segmentId, input.delta);
+        return;
+    }
+    output.replaceTextSegmentSnapshot(segmentId, input.text);
+}
 function nextCommandBlockId(tracker, turnId, itemId) {
     const stableTurnId = turnId ?? 'turn';
     if (itemId)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.19.0",
+  "version": "0.19.2",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/index.js",
@@ -29,12 +29,12 @@
     "prepack": "npm run build"
   },
   "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/agent-host": "^0.4.0",
+    "@canonmsg/agent-sdk": "^3.4.4",
+    "@canonmsg/backend-contracts": "^1.8.1",
+    "@canonmsg/bridge": "^0.2.1",
+    "@canonmsg/core": "^3.2.0",
+    "@canonmsg/framework": "^0.2.1"
   },
   "engines": {
     "node": ">=18.0.0"