@canonmsg/codex-plugin 0.19.1 → 0.20.0

package/README.md

@@ -47,9 +47,9 @@ You do not need a git repo for host mode. The plugin passes `--skip-git-repo-che
 - Interrupt by terminating the active Codex turn
 - Tool/running status surfaced while Codex is working
 
-## Current limitation
+## Transport
 
-The stable `codex exec --json` surface exposes thinking state, tool activity, and completed assistant-message previews, but not token-by-token text deltas. v1 therefore publishes live progress and assistant-message snapshots without claiming true token streaming.
+`canon-codex` drives Codex through the `codex app-server` JSON-RPC transport — the only supported transport. Canon routes native plan mode, runtime questions, approvals, tools, and live message deltas. A Codex CLI new enough to provide `codex app-server` is required.
 
 Current Canon control truth for Codex host mode:
 

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

@@ -1,4 +1,57 @@
-import type { CodexApprovalPolicy, CodexEvent, CodexRunTurnOptions, CodexSandboxMode, CodexTurnResult } from './adapter.js';
+export type CodexSandboxMode = 'read-only' | 'workspace-write' | 'danger-full-access';
+export type CodexApprovalPolicy = 'untrusted' | 'on-request' | 'never';
+export type CodexEvent = {
+    type: 'thread.started';
+    threadId: string;
+} | {
+    type: 'turn.started';
+} | {
+    type: 'message';
+    text: string;
+    delta?: string;
+    itemId?: string;
+} | {
+    type: 'plan.updated';
+    text: string;
+} | {
+    type: 'waiting';
+    reason: string;
+} | {
+    type: 'command.started';
+    command: string;
+    itemId?: string;
+} | {
+    type: 'command.completed';
+    command: string;
+    output: string;
+    exitCode: number | null;
+    itemId?: string;
+} | {
+    type: 'turn.completed';
+    usage?: {
+        input_tokens?: number;
+        cached_input_tokens?: number;
+        output_tokens?: number;
+    };
+} | {
+    type: 'skills.changed';
+};
+export interface CodexServerRequest {
+    id: string | number;
+    method: string;
+    params: Record<string, unknown>;
+}
+export interface CodexRunTurnOptions {
+    planMode?: boolean;
+    onServerRequest?: (request: CodexServerRequest) => Promise<unknown>;
+}
+export interface CodexTurnResult {
+    threadId: string | null;
+    finalMessage: string | null;
+    exitCode: number | null;
+    interrupted: boolean;
+    errorText: string | null;
+}
 export type JsonRecord = Record<string, unknown>;
 export interface CodexSkillMetadata {
     name: string;
@@ -14,7 +67,6 @@ export declare class CodexAppServerAdapter {
     private model;
     private reasoningEffort;
     private readonly sandbox;
-    private readonly legacyApprovalPolicy;
     private readonly addDirs;
     private readonly configOverrides;
     private readonly fullAuto;
@@ -39,6 +91,7 @@ export declare class CodexAppServerAdapter {
     private skillsCache;
     private messageTextByItem;
     private planText;
+    private traceTurnEpochMs;
     constructor(opts: {
         cwd: string;
         threadId?: string | null;
@@ -46,7 +99,6 @@ export declare class CodexAppServerAdapter {
         model?: string | null;
         reasoningEffort?: string | null;
         sandbox?: CodexSandboxMode | null;
-        approvalPolicy?: CodexApprovalPolicy | null;
         addDirs?: string[];
         configOverrides?: string[];
         fullAuto?: boolean;
@@ -96,4 +148,6 @@ export declare class CodexAppServerAdapter {
     private clearActiveTurn;
     private sendRequest;
     private write;
+    private trace;
+    private traceLine;
 }

package/dist/app-server-adapter.js

@@ -6,7 +6,6 @@ export class CodexAppServerAdapter {
     model;
     reasoningEffort;
     sandbox;
-    legacyApprovalPolicy;
     addDirs;
     configOverrides;
     fullAuto;
@@ -31,6 +30,7 @@ export class CodexAppServerAdapter {
     skillsCache = null;
     messageTextByItem = new Map();
     planText = '';
+    traceTurnEpochMs = null;
     constructor(opts) {
         this.cwd = opts.cwd;
         this.threadId = opts.threadId ?? null;
@@ -38,7 +38,6 @@ export class CodexAppServerAdapter {
         this.model = opts.model ?? null;
         this.reasoningEffort = opts.reasoningEffort ?? null;
         this.sandbox = opts.sandbox ?? null;
-        this.legacyApprovalPolicy = opts.approvalPolicy ?? null;
         this.addDirs = opts.addDirs ?? [];
         this.configOverrides = opts.configOverrides ?? [];
         this.fullAuto = opts.fullAuto ?? false;
@@ -117,6 +116,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 +159,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 +175,7 @@ export class CodexAppServerAdapter {
                     },
                 },
             });
+            this.trace('turn/start ack');
             const turn = turnStarted.turn;
             if (this.currentTurnResolve) {
                 this.currentTurnId = readString(turn, 'id') ?? null;
@@ -187,7 +191,7 @@ export class CodexAppServerAdapter {
     resolveApprovalPolicy() {
         if (this.bypassApprovalsAndSandbox || this.fullAuto)
             return 'never';
-        return this.legacyApprovalPolicy;
+        return null;
     }
     configPayload() {
         const config = {};
@@ -322,6 +326,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);
@@ -395,7 +400,7 @@ export class CodexAppServerAdapter {
             this.messageTextByItem.set(itemId, next);
             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') {
@@ -467,6 +472,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') {
@@ -530,6 +536,7 @@ export class CodexAppServerAdapter {
         this.currentErrorText = null;
         this.messageTextByItem.clear();
         this.planText = '';
+        this.traceTurnEpochMs = null;
     }
     sendRequest(method, params) {
         const id = this.requestSeq++;
@@ -549,6 +556,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

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 import { setDefaultResultOrder } from 'node:dns';
 import { randomUUID } from 'node:crypto';
-import { spawnSync } from 'node:child_process';
 import { dirname } from 'node:path';
 import { parseArgs } from 'node:util';
 import { getCodexImagePath, inferUploadMimeType, materializeMessageMedia, materializeReplyContextMedia, } from '@canonmsg/agent-sdk';
@@ -16,8 +15,7 @@ import { STARTUP_RECOVERY_MAX_MESSAGES, STARTUP_RECOVERY_PAGE_SIZE, captureTurnA
 import { RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildRuntimeCardOutcome, buildPlanApprovalRequest, resolveQuestionAllowOther, buildCanonTurnContextV2, buildFirstPartyCodingRuntimeDescriptor, buildRuntimePresentationPolicy, buildCanonInboundFrameV1, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, EXECUTION_ENVIRONMENT_MODES, DEFAULT_RUNTIME_CAPABILITIES, normalizeTurnMetadata, parseRuntimeCardV1, shouldTriggerAgentTurn, renderCanonHostInboundContent, renderCodingHostInboundPrompt, } from '@canonmsg/core/contract';
 import { ExecutionEnvironmentError, buildConfiguredWorkspaceOptionsWithRoots, buildLocalRuntimeId, buildPublicWorkspaceOptions, buildPublicWorkspaceRoots, heartbeatLocalRuntimeEntry, loadRuntimeSessionState, markLocalRuntimeStopped, prepareConversationEnvironment, releaseConversationEnvironment, resolveCanonAgent, saveRuntimeSessionState, upsertLocalRuntimeEntry, } from '@canonmsg/core/local';
 import { readHostSessionConfig, resolveHostWorkspaceCwd, } from '@canonmsg/core/host';
-import { CodexConversationAdapter, } from './adapter.js';
-import { CodexAppServerAdapter } from './app-server-adapter.js';
+import { CodexAppServerAdapter, } from './app-server-adapter.js';
 import { CODEX_APP_DYNAMIC_TOOLS, deniedCodexAppToolResult, handleCodexAppToolCall, isCodexAppToolCall, } from './codex-app-tools.js';
 import { mapCanonApprovalResultToCodexDecision, mapCodexAppServerApprovalRequest, } from './app-server-approval.js';
 import { clearStoredThreadId, buildCodexThreadPolicyFingerprint, loadStoredThreadId, saveStoredThreadId, } from './session-store.js';
@@ -26,7 +24,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, hasSpeechSegmentText, 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 +106,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 —
@@ -319,9 +346,7 @@ function resolveCodexEffectiveRuntimePolicy(input) {
     }
     const approvalOverride = mapCanonPermissionToCodex(permissionMode);
     const defaultSandbox = (stringArg(input.args, 'sandbox') ?? null);
-    const defaultApprovalPolicy = (stringArg(input.args, 'ask-for-approval') ?? null);
     const sandbox = approvalOverride ? approvalOverride.sandbox : defaultSandbox;
-    const approvalPolicy = approvalOverride ? null : defaultApprovalPolicy;
     const fullAuto = approvalOverride ? approvalOverride.fullAuto : boolArg(input.args, 'full-auto');
     const bypassApprovalsAndSandbox = approvalOverride
         ? approvalOverride.bypassApprovalsAndSandbox
@@ -331,7 +356,6 @@ function resolveCodexEffectiveRuntimePolicy(input) {
         executionMode: input.environment.mode,
         permissionMode: permissionMode ?? null,
         sandbox,
-        approvalPolicy,
         fullAuto,
         bypassApprovalsAndSandbox,
     });
@@ -339,7 +363,6 @@ function resolveCodexEffectiveRuntimePolicy(input) {
         ...(model ? { model } : {}),
         ...(permissionMode ? { permissionMode } : {}),
         sandbox,
-        approvalPolicy,
         fullAuto,
         bypassApprovalsAndSandbox,
         fingerprint,
@@ -397,17 +420,6 @@ function stringArgs(value) {
         ? value.filter((item) => typeof item === 'string' && item.trim().length > 0)
         : undefined;
 }
-function supportsCodexAppServer(codexBin) {
-    if (process.env.CANON_CODEX_TRANSPORT === 'exec')
-        return false;
-    if (process.env.CANON_CODEX_TRANSPORT === 'app-server')
-        return true;
-    const result = spawnSync(codexBin, ['app-server', '--help'], {
-        encoding: 'utf8',
-        stdio: ['ignore', 'ignore', 'ignore'],
-    });
-    return result.status === 0;
-}
 function parsePlanCommand(content) {
     const trimmed = content.trimStart();
     if (!trimmed.startsWith('/plan'))
@@ -483,7 +495,6 @@ export async function main() {
             model: { type: 'string' },
             sandbox: { type: 'string' },
             'ask-for-approval': { type: 'string' },
-            'codex-profile': { type: 'string' },
             'add-dir': { type: 'string', multiple: true },
             workspace: { type: 'string', multiple: true },
             'workspace-root': { type: 'string', multiple: true },
@@ -516,14 +527,12 @@ export async function main() {
     }
     const codexBin = typeof args['codex-bin'] === 'string' ? args['codex-bin'] : 'codex';
     const codexCliStatus = detectCodexCliVersion(codexBin);
-    const useAppServer = supportsCodexAppServer(codexBin);
     if (codexCliStatus.version) {
         console.error(`[canon-codex] Detected Codex CLI ${codexCliStatus.version} (${codexBin})`);
     }
     else {
         console.error(`[canon-codex] Could not detect Codex CLI version for ${codexBin}: ${codexCliStatus.error ?? 'unknown result'}`);
     }
-    console.error(`[canon-codex] Codex transport: ${useAppServer ? 'app-server' : 'exec --json'}`);
     const { agentName: profileAgentName, profile, lockHandle, } = resolveCanonAgent({ logPrefix: '[canon-codex]', expectedClientType: 'codex' });
     activeLockHandle = lockHandle ?? null;
     console.error(`[canon-codex] Starting${profile ? ` (profile: ${profile})` : ''} in ${workingDir}`);
@@ -554,7 +563,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}`);
     });
@@ -718,35 +727,19 @@ export async function main() {
                 const initialEffort = config?.effort && CODEX_EFFORT_VALUES.has(config.effort)
                     ? config.effort
                     : null;
-                const adapter = useAppServer
-                    ? new CodexAppServerAdapter({
-                        cwd: sessionCwd,
-                        threadId: storedThreadId,
-                        codexBin,
-                        model: policy.model ?? null,
-                        reasoningEffort: initialEffort,
-                        sandbox: policy.sandbox,
-                        approvalPolicy: policy.approvalPolicy,
-                        addDirs: args['add-dir'] ?? [],
-                        configOverrides: args.config ?? [],
-                        fullAuto: policy.fullAuto,
-                        bypassApprovalsAndSandbox: policy.bypassApprovalsAndSandbox,
-                        dynamicTools: CODEX_APP_DYNAMIC_TOOLS,
-                    })
-                    : new CodexConversationAdapter({
-                        cwd: sessionCwd,
-                        threadId: storedThreadId,
-                        codexBin,
-                        model: policy.model ?? null,
-                        reasoningEffort: initialEffort,
-                        sandbox: policy.sandbox,
-                        approvalPolicy: policy.approvalPolicy,
-                        codexProfile: typeof args['codex-profile'] === 'string' ? args['codex-profile'] : null,
-                        addDirs: args['add-dir'] ?? [],
-                        configOverrides: args.config ?? [],
-                        fullAuto: policy.fullAuto,
-                        bypassApprovalsAndSandbox: policy.bypassApprovalsAndSandbox,
-                    });
+                const adapter = new CodexAppServerAdapter({
+                    cwd: sessionCwd,
+                    threadId: storedThreadId,
+                    codexBin,
+                    model: policy.model ?? null,
+                    reasoningEffort: initialEffort,
+                    sandbox: policy.sandbox,
+                    addDirs: args['add-dir'] ?? [],
+                    configOverrides: args.config ?? [],
+                    fullAuto: policy.fullAuto,
+                    bypassApprovalsAndSandbox: policy.bypassApprovalsAndSandbox,
+                    dynamicTools: CODEX_APP_DYNAMIC_TOOLS,
+                });
                 // eslint-disable-next-line prefer-const -- session must be declared before the module closures but assigned after them
                 let session;
                 // ── Per-session RTDB writers (generic skeleton from @canonmsg/agent-host) ──
@@ -976,7 +969,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') {
@@ -1304,9 +1302,6 @@ export async function main() {
         const params = request.params;
         const expiresAt = Date.now() + 30 * 60_000;
         if (request.method === 'item/tool/call' && isCodexAppToolCall(params)) {
-            if (!(session.adapter instanceof CodexAppServerAdapter)) {
-                return deniedCodexAppToolResult('codex_app tools require the Codex app-server transport.');
-            }
             if (!session.currentTurnCanUseCodexAppTools) {
                 return deniedCodexAppToolResult('Only the Canon owner can use codex_app tools.');
             }
@@ -1537,11 +1532,9 @@ export async function main() {
         const renderedContent = renderInboundContent(input.message, materialized);
         const turnMetadata = normalizeTurnMetadata(input.message.metadata);
         const requestedPlanMode = turnMetadata?.requestedTurnMode === 'plan';
-        const planCommand = useAppServer
-            ? requestedPlanMode
-                ? { planMode: true, content: renderedContent }
-                : parsePlanCommand(renderedContent)
-            : { planMode: false, content: renderedContent };
+        const planCommand = requestedPlanMode
+            ? { planMode: true, content: renderedContent }
+            : parsePlanCommand(renderedContent);
         const content = planCommand.content;
         const hydrated = await loadHydratedInboundContext({
             conversationId: input.conversationId,
@@ -1716,16 +1709,14 @@ export async function main() {
             permissionModes: [...codexPermissionEnvelope.availablePermissionModes],
             defaultPermissionMode: codexPermissionEnvelope.defaultPermissionMode,
             presentation: runtimePresentation,
-            supportsPlanMode: useAppServer,
-            supportsCompact: useAppServer,
-            supportsRichCards: useAppServer,
+            supportsPlanMode: true,
+            supportsCompact: true,
+            supportsRichCards: true,
             skills: codexSkills,
         }),
     });
     let runtimeDescriptor = buildCurrentRuntimeDescriptor();
     async function refreshCodexSkillInventory(forceReload = false) {
-        if (!useAppServer)
-            return;
         const probe = new CodexAppServerAdapter({
             cwd: workingDir,
             codexBin,
@@ -1810,10 +1801,6 @@ export async function main() {
             console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Cannot compact context: no live Codex session`);
             return;
         }
-        if (!(session.adapter instanceof CodexAppServerAdapter)) {
-            console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Cannot compact context: compact is only available for Codex app-server sessions`);
-            return;
-        }
         try {
             await session.adapter.compactThread();
             console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Compact requested`);
@@ -1896,24 +1883,16 @@ export async function main() {
                 const payload = {
                     descriptor,
                     surfaceMode: 'host',
-                    // The exec --json transport cannot block on approvals — without a
-                    // strip-level warning a user can believe they have an approval
-                    // gate they do not have.
-                    ...(useAppServer
-                        ? {}
-                        : { warning: "Approvals can't block on this Codex CLI — update Codex to enable the app-server transport and approval gates." }),
                     statusItems: [
                         {
                             id: 'transport',
                             label: 'Transport',
-                            value: useAppServer ? 'app-server' : 'exec --json',
+                            value: 'app-server',
                         },
                         {
                             id: 'streaming',
                             label: 'Live output',
-                            value: useAppServer
-                                ? 'Plans, questions, approvals, tools, and message deltas'
-                                : 'Thinking, tools, and completed-message previews',
+                            value: 'Plans, questions, approvals, tools, and message deltas',
                         },
                         {
                             id: 'codex-cli',
@@ -1924,8 +1903,7 @@ export async function main() {
                         {
                             id: 'nativeActions',
                             label: 'Native actions',
-                            value: useAppServer ? 'Enabled' : 'Limited until app-server transport',
-                            ...(useAppServer ? {} : { tone: 'warning' }),
+                            value: 'Enabled',
                         },
                         {
                             id: 'mediaOut',
@@ -1944,9 +1922,7 @@ export async function main() {
                         fallbackReason: resolveExecutionFallbackReason(session?.environment),
                     },
                     notes: [
-                        useAppServer
-                            ? 'This Codex host uses the app-server transport, so Canon can route native plan mode, runtime questions, approvals, and live turn updates.'
-                            : 'This Codex host uses the current exec --json transport, so Canon can show thinking, tool activity, and completed assistant-message previews, but not native plan questions or structured approvals.',
+                        'This Codex host uses the app-server transport, so Canon can route native plan mode, runtime questions, approvals, and live turn updates.',
                     ],
                 };
                 await port.publishRuntimeStatus({

package/dist/permission-mode.d.ts

@@ -1,4 +1,4 @@
-import type { CodexSandboxMode } from './adapter.js';
+import type { CodexSandboxMode } from './app-server-adapter.js';
 export declare const CODEX_PERMISSION_OPTIONS: readonly [{
     readonly value: "readonly";
     readonly label: "Read-only";

package/dist/turn-activity.d.ts

@@ -24,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

@@ -27,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.1",
+  "version": "0.20.0",
   "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.1",
-    "@canonmsg/bridge": "^0.2.1",
-    "@canonmsg/core": "^3.1.1",
-    "@canonmsg/framework": "^0.2.1"
+    "@canonmsg/agent-host": "^0.5.0",
+    "@canonmsg/agent-sdk": "^4.0.0",
+    "@canonmsg/backend-contracts": "^1.9.0",
+    "@canonmsg/bridge": "^0.3.0",
+    "@canonmsg/core": "^3.3.0",
+    "@canonmsg/framework": "^0.3.0"
   },
   "engines": {
     "node": ">=18.0.0"

package/dist/adapter.d.ts

@@ -1,96 +0,0 @@
-export type CodexSandboxMode = 'read-only' | 'workspace-write' | 'danger-full-access';
-export type CodexApprovalPolicy = 'untrusted' | 'on-request' | 'never';
-export type CodexEvent = {
-    type: 'thread.started';
-    threadId: string;
-} | {
-    type: 'turn.started';
-} | {
-    type: 'message';
-    text: string;
-    itemId?: string;
-} | {
-    type: 'plan.updated';
-    text: string;
-} | {
-    type: 'waiting';
-    reason: string;
-} | {
-    type: 'command.started';
-    command: string;
-    itemId?: string;
-} | {
-    type: 'command.completed';
-    command: string;
-    output: string;
-    exitCode: number | null;
-    itemId?: string;
-} | {
-    type: 'turn.completed';
-    usage?: {
-        input_tokens?: number;
-        cached_input_tokens?: number;
-        output_tokens?: number;
-    };
-} | {
-    type: 'skills.changed';
-};
-export interface CodexServerRequest {
-    id: string | number;
-    method: string;
-    params: Record<string, unknown>;
-}
-export interface CodexRunTurnOptions {
-    planMode?: boolean;
-    onServerRequest?: (request: CodexServerRequest) => Promise<unknown>;
-}
-export interface CodexTurnResult {
-    threadId: string | null;
-    finalMessage: string | null;
-    exitCode: number | null;
-    interrupted: boolean;
-    errorText: string | null;
-}
-export declare class CodexConversationAdapter {
-    private readonly cwd;
-    private readonly codexBin;
-    private model;
-    private reasoningEffort;
-    private readonly sandbox;
-    private readonly legacyApprovalPolicy;
-    private readonly codexProfile;
-    private readonly addDirs;
-    private readonly configOverrides;
-    private readonly fullAuto;
-    private readonly bypassApprovalsAndSandbox;
-    private child;
-    private threadId;
-    private interruptTimer;
-    private interrupted;
-    constructor(opts: {
-        cwd: string;
-        threadId?: string | null;
-        codexBin?: string;
-        model?: string | null;
-        reasoningEffort?: string | null;
-        sandbox?: CodexSandboxMode | null;
-        approvalPolicy?: CodexApprovalPolicy | null;
-        codexProfile?: string | null;
-        addDirs?: string[];
-        configOverrides?: string[];
-        fullAuto?: boolean;
-        bypassApprovalsAndSandbox?: boolean;
-    });
-    getThreadId(): string | null;
-    clearThreadId(): void;
-    setModel(model: string | null): void;
-    /** Sets GPT reasoning effort, applied on the next turn via `-c model_reasoning_effort`. */
-    setReasoningEffort(effort: string | null): void;
-    isRunning(): boolean;
-    interrupt(): Promise<void>;
-    runTurn(prompt: string, onEvent: (event: CodexEvent) => void, onLog?: (line: string) => void, imagePaths?: readonly string[], extraAddDirs?: readonly string[], _options?: CodexRunTurnOptions): Promise<CodexTurnResult>;
-    private buildAddDirs;
-    private buildArgs;
-    private canResumeWithCurrentPolicy;
-    private clearActiveProcess;
-}

package/dist/adapter.js

@@ -1,310 +0,0 @@
-import { spawn } from 'node:child_process';
-import { createInterface } from 'node:readline';
-import { isRecoverableCodexThreadError } from './error-format.js';
-export class CodexConversationAdapter {
-    cwd;
-    codexBin;
-    model;
-    reasoningEffort;
-    sandbox;
-    legacyApprovalPolicy;
-    codexProfile;
-    addDirs;
-    configOverrides;
-    fullAuto;
-    bypassApprovalsAndSandbox;
-    child = null;
-    threadId;
-    interruptTimer = null;
-    interrupted = false;
-    constructor(opts) {
-        this.cwd = opts.cwd;
-        this.threadId = opts.threadId ?? null;
-        this.codexBin = opts.codexBin ?? 'codex';
-        this.model = opts.model ?? null;
-        this.reasoningEffort = opts.reasoningEffort ?? null;
-        this.sandbox = opts.sandbox ?? null;
-        this.legacyApprovalPolicy = opts.approvalPolicy ?? null;
-        this.codexProfile = opts.codexProfile ?? null;
-        this.addDirs = opts.addDirs ?? [];
-        this.configOverrides = opts.configOverrides ?? [];
-        this.fullAuto = opts.fullAuto ?? false;
-        this.bypassApprovalsAndSandbox = opts.bypassApprovalsAndSandbox ?? false;
-    }
-    getThreadId() {
-        return this.threadId;
-    }
-    clearThreadId() {
-        this.threadId = null;
-    }
-    setModel(model) {
-        this.model = model;
-    }
-    /** Sets GPT reasoning effort, applied on the next turn via `-c model_reasoning_effort`. */
-    setReasoningEffort(effort) {
-        this.reasoningEffort = effort && effort.trim() ? effort.trim() : null;
-    }
-    isRunning() {
-        return this.child !== null;
-    }
-    async interrupt() {
-        if (!this.child)
-            return;
-        this.interrupted = true;
-        this.child.kill('SIGINT');
-        this.interruptTimer = setTimeout(() => {
-            if (this.child)
-                this.child.kill('SIGKILL');
-        }, 5_000);
-    }
-    async runTurn(prompt, onEvent, onLog, imagePaths = [], extraAddDirs = [], _options = {}) {
-        if (this.child) {
-            throw new Error('A Codex turn is already in progress for this conversation');
-        }
-        const args = this.buildArgs(prompt, imagePaths, extraAddDirs);
-        const child = spawn(this.codexBin, args, {
-            cwd: this.cwd,
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-        this.child = child;
-        this.interrupted = false;
-        let latestMessage = null;
-        let lastErrorText = null;
-        const stdout = createInterface({ input: child.stdout });
-        const stderr = createInterface({ input: child.stderr });
-        stdout.on('line', (line) => {
-            const event = parseEventLine(line);
-            if (!event)
-                return;
-            switch (event.type) {
-                case 'thread.started':
-                    this.threadId = event.thread_id;
-                    onEvent({ type: 'thread.started', threadId: event.thread_id });
-                    break;
-                case 'turn.started':
-                    onEvent({ type: 'turn.started' });
-                    break;
-                case 'item.started':
-                    if (event.item?.type === 'command_execution') {
-                        onEvent({
-                            type: 'command.started',
-                            command: String(event.item.command ?? ''),
-                            ...(typeof event.item.id === 'string' && event.item.id.trim()
-                                ? { itemId: event.item.id.trim() }
-                                : {}),
-                        });
-                    }
-                    break;
-                case 'item.completed':
-                    if (event.item?.type === 'agent_message') {
-                        latestMessage = normalizeMessageText(event.item.text);
-                        if (latestMessage) {
-                            onEvent({
-                                type: 'message',
-                                text: latestMessage,
-                                ...(typeof event.item.id === 'string' && event.item.id.trim()
-                                    ? { itemId: event.item.id.trim() }
-                                    : {}),
-                            });
-                        }
-                    }
-                    else if (event.item?.type === 'command_execution') {
-                        onEvent({
-                            type: 'command.completed',
-                            command: String(event.item.command ?? ''),
-                            output: String(event.item.aggregated_output ?? ''),
-                            exitCode: typeof event.item.exit_code === 'number' ? event.item.exit_code : null,
-                            ...(typeof event.item.id === 'string' && event.item.id.trim()
-                                ? { itemId: event.item.id.trim() }
-                                : {}),
-                        });
-                    }
-                    break;
-                case 'turn.completed':
-                    onEvent({ type: 'turn.completed', usage: event.usage });
-                    break;
-                case 'error':
-                    lastErrorText = normalizeErrorText(event.message) ?? lastErrorText;
-                    break;
-                case 'turn.failed':
-                    lastErrorText = normalizeErrorText(event.error?.message ?? event.message) ?? lastErrorText;
-                    break;
-                default:
-                    break;
-            }
-        });
-        stderr.on('line', (line) => {
-            const trimmed = line.trim();
-            if (!trimmed)
-                return;
-            if (isIgnorableCodexLog(trimmed))
-                return;
-            lastErrorText = trimmed;
-            if (isRecoverableCodexThreadError(trimmed))
-                return;
-            onLog?.(trimmed);
-        });
-        return await new Promise((resolve, reject) => {
-            child.on('error', (error) => {
-                this.clearActiveProcess();
-                reject(error);
-            });
-            child.on('close', (code) => {
-                stdout.close();
-                stderr.close();
-                const interrupted = this.interrupted || code === 130;
-                const result = {
-                    threadId: this.threadId,
-                    finalMessage: latestMessage,
-                    exitCode: code,
-                    interrupted,
-                    errorText: interrupted ? null : lastErrorText,
-                };
-                this.clearActiveProcess();
-                resolve(result);
-            });
-        });
-    }
-    buildAddDirs(extraAddDirs = []) {
-        const seen = new Set();
-        const dirs = [];
-        for (const value of [...this.addDirs, ...extraAddDirs]) {
-            const trimmed = value.trim();
-            if (!trimmed || seen.has(trimmed))
-                continue;
-            seen.add(trimmed);
-            dirs.push(value);
-        }
-        return dirs;
-    }
-    buildArgs(prompt, imagePaths = [], extraAddDirs = []) {
-        if (this.threadId && this.canResumeWithCurrentPolicy()) {
-            const args = ['exec', 'resume', '--json', '--skip-git-repo-check'];
-            if (this.model) {
-                args.push('-m', this.model);
-            }
-            if (this.codexProfile) {
-                args.push('-p', this.codexProfile);
-            }
-            for (const configOverride of this.configOverrides) {
-                args.push('-c', configOverride);
-            }
-            if (this.reasoningEffort) {
-                args.push('-c', `model_reasoning_effort="${this.reasoningEffort}"`);
-            }
-            for (const addDir of this.buildAddDirs(extraAddDirs)) {
-                args.push('--add-dir', addDir);
-            }
-            if (this.fullAuto) {
-                args.push('--full-auto');
-            }
-            if (this.bypassApprovalsAndSandbox) {
-                args.push('--dangerously-bypass-approvals-and-sandbox');
-            }
-            for (const imagePath of imagePaths) {
-                args.push('-i', imagePath);
-            }
-            if (imagePaths.length > 0) {
-                args.push('--');
-            }
-            args.push(this.threadId, prompt);
-            return args;
-        }
-        if (this.threadId) {
-            this.threadId = null;
-        }
-        const args = ['exec', '--json', '--color', 'never', '-C', this.cwd, '--skip-git-repo-check'];
-        const execMode = resolveExecMode({
-            sandbox: this.sandbox,
-            fullAuto: this.fullAuto,
-            bypassApprovalsAndSandbox: this.bypassApprovalsAndSandbox,
-        });
-        if (this.model) {
-            args.push('-m', this.model);
-        }
-        if (this.sandbox) {
-            args.push('-s', this.sandbox);
-        }
-        if (this.codexProfile) {
-            args.push('-p', this.codexProfile);
-        }
-        for (const addDir of this.buildAddDirs(extraAddDirs)) {
-            args.push('--add-dir', addDir);
-        }
-        for (const configOverride of this.configOverrides) {
-            args.push('-c', configOverride);
-        }
-        if (this.reasoningEffort) {
-            args.push('-c', `model_reasoning_effort="${this.reasoningEffort}"`);
-        }
-        if (execMode.fullAuto) {
-            args.push('--full-auto');
-        }
-        if (execMode.bypassApprovalsAndSandbox) {
-            args.push('--dangerously-bypass-approvals-and-sandbox');
-        }
-        for (const imagePath of imagePaths) {
-            args.push('-i', imagePath);
-        }
-        if (imagePaths.length > 0) {
-            args.push('--');
-        }
-        args.push(prompt);
-        return args;
-    }
-    canResumeWithCurrentPolicy() {
-        if (this.bypassApprovalsAndSandbox || this.fullAuto) {
-            return true;
-        }
-        return this.sandbox === null;
-    }
-    clearActiveProcess() {
-        if (this.interruptTimer) {
-            clearTimeout(this.interruptTimer);
-            this.interruptTimer = null;
-        }
-        this.child = null;
-    }
-}
-function parseEventLine(line) {
-    const trimmed = line.trim();
-    if (!trimmed.startsWith('{'))
-        return null;
-    try {
-        return JSON.parse(trimmed);
-    }
-    catch {
-        return null;
-    }
-}
-function normalizeMessageText(value) {
-    if (typeof value !== 'string')
-        return null;
-    const text = value.trim();
-    return text ? text : null;
-}
-function normalizeErrorText(value) {
-    if (typeof value !== 'string')
-        return null;
-    const text = value.trim();
-    return text ? text : null;
-}
-function resolveExecMode(input) {
-    if (input.bypassApprovalsAndSandbox) {
-        return { fullAuto: false, bypassApprovalsAndSandbox: true };
-    }
-    if (input.fullAuto) {
-        return { fullAuto: true, bypassApprovalsAndSandbox: false };
-    }
-    return { fullAuto: false, bypassApprovalsAndSandbox: false };
-}
-function isIgnorableCodexLog(line) {
-    return [
-        'Reading additional input from stdin...',
-        'ignoring interface.defaultPrompt',
-        'state db discrepancy during find_thread_path_by_id_str_in_subdir',
-        'failed to open state db',
-        'failed to initialize state runtime',
-        'Failed to delete shell snapshot',
-    ].some((pattern) => line.includes(pattern));
-}