@canonmsg/codex-plugin 0.11.11 → 0.12.0

package/dist/adapter.d.ts

@@ -8,6 +8,12 @@ export type CodexEvent = {
 } | {
     type: 'message';
     text: string;
+} | {
+    type: 'plan.updated';
+    text: string;
+} | {
+    type: 'waiting';
+    reason: string;
 } | {
     type: 'command.started';
     command: string;
@@ -24,6 +30,15 @@ export type CodexEvent = {
         output_tokens?: number;
     };
 };
+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;
@@ -64,7 +79,7 @@ export declare class CodexConversationAdapter {
     setModel(model: 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[]): Promise<CodexTurnResult>;
+    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;

package/dist/adapter.js

@@ -51,7 +51,7 @@ export class CodexConversationAdapter {
                 this.child.kill('SIGKILL');
         }, 5_000);
     }
-    async runTurn(prompt, onEvent, onLog, imagePaths = [], extraAddDirs = []) {
+    async runTurn(prompt, onEvent, onLog, imagePaths = [], extraAddDirs = [], _options = {}) {
         if (this.child) {
             throw new Error('A Codex turn is already in progress for this conversation');
         }

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

@@ -0,0 +1,62 @@
+import type { CodexApprovalPolicy, CodexEvent, CodexRunTurnOptions, CodexSandboxMode, CodexTurnResult } from './adapter.js';
+export declare class CodexAppServerAdapter {
+    private readonly cwd;
+    private readonly codexBin;
+    private model;
+    private readonly sandbox;
+    private readonly legacyApprovalPolicy;
+    private readonly addDirs;
+    private readonly configOverrides;
+    private readonly fullAuto;
+    private readonly bypassApprovalsAndSandbox;
+    private child;
+    private threadId;
+    private loadedThreadId;
+    private resolvedModel;
+    private currentTurnId;
+    private requestSeq;
+    private pending;
+    private currentOnEvent;
+    private currentOnLog;
+    private currentRequestHandler;
+    private currentTurnResolve;
+    private currentTurnReject;
+    private currentFinalMessage;
+    private currentErrorText;
+    private interrupted;
+    private initialized;
+    private messageTextByItem;
+    private planText;
+    constructor(opts: {
+        cwd: string;
+        threadId?: string | null;
+        codexBin?: string;
+        model?: string | null;
+        sandbox?: CodexSandboxMode | null;
+        approvalPolicy?: CodexApprovalPolicy | null;
+        addDirs?: string[];
+        configOverrides?: string[];
+        fullAuto?: boolean;
+        bypassApprovalsAndSandbox?: boolean;
+    });
+    getThreadId(): string | null;
+    clearThreadId(): void;
+    setModel(model: string | null): void;
+    isRunning(): boolean;
+    interrupt(): Promise<void>;
+    close(): void;
+    runTurn(prompt: string, onEvent: (event: CodexEvent) => void, onLog?: (line: string) => void, imagePaths?: readonly string[], _extraAddDirs?: readonly string[], options?: CodexRunTurnOptions): Promise<CodexTurnResult>;
+    private resolveApprovalPolicy;
+    private configPayload;
+    private rememberResolvedModel;
+    private sandboxPolicyPayload;
+    private buildWritableRoots;
+    private ensureStarted;
+    private handleLine;
+    private handleServerRequest;
+    private handleNotification;
+    private resolveCurrentTurn;
+    private clearActiveTurn;
+    private sendRequest;
+    private write;
+}

package/dist/app-server-adapter.js

@@ -0,0 +1,502 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+export class CodexAppServerAdapter {
+    cwd;
+    codexBin;
+    model;
+    sandbox;
+    legacyApprovalPolicy;
+    addDirs;
+    configOverrides;
+    fullAuto;
+    bypassApprovalsAndSandbox;
+    child = null;
+    threadId;
+    loadedThreadId = null;
+    resolvedModel = null;
+    currentTurnId = null;
+    requestSeq = 1;
+    pending = new Map();
+    currentOnEvent = null;
+    currentOnLog = null;
+    currentRequestHandler = null;
+    currentTurnResolve = null;
+    currentTurnReject = null;
+    currentFinalMessage = null;
+    currentErrorText = null;
+    interrupted = false;
+    initialized = false;
+    messageTextByItem = new Map();
+    planText = '';
+    constructor(opts) {
+        this.cwd = opts.cwd;
+        this.threadId = opts.threadId ?? null;
+        this.codexBin = opts.codexBin ?? 'codex';
+        this.model = opts.model ?? null;
+        this.sandbox = opts.sandbox ?? null;
+        this.legacyApprovalPolicy = opts.approvalPolicy ?? 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;
+        this.loadedThreadId = null;
+        this.resolvedModel = null;
+    }
+    setModel(model) {
+        this.model = model;
+    }
+    isRunning() {
+        return this.currentTurnId !== null || this.currentTurnResolve !== null;
+    }
+    async interrupt() {
+        if (!this.threadId || !this.currentTurnId)
+            return;
+        this.interrupted = true;
+        await this.sendRequest('turn/interrupt', {
+            threadId: this.threadId,
+            turnId: this.currentTurnId,
+        }).catch(() => { });
+    }
+    close() {
+        this.child?.kill('SIGTERM');
+        this.child = null;
+        this.initialized = false;
+        this.clearActiveTurn();
+    }
+    async runTurn(prompt, onEvent, onLog, imagePaths = [], _extraAddDirs = [], options = {}) {
+        if (this.currentTurnId || this.currentTurnResolve) {
+            throw new Error('A Codex turn is already in progress for this conversation');
+        }
+        await this.ensureStarted();
+        this.currentOnEvent = onEvent;
+        this.currentOnLog = onLog ?? null;
+        this.currentRequestHandler = options.onServerRequest ?? null;
+        this.currentFinalMessage = null;
+        this.currentErrorText = null;
+        this.interrupted = false;
+        this.messageTextByItem.clear();
+        this.planText = '';
+        try {
+            if (this.threadId && this.loadedThreadId !== this.threadId) {
+                const resumed = await this.sendRequest('thread/resume', {
+                    threadId: this.threadId,
+                    cwd: this.cwd,
+                    ...(this.model ? { model: this.model } : {}),
+                    ...(this.sandbox ? { sandbox: this.sandbox } : {}),
+                    ...this.configPayload(),
+                    approvalPolicy: this.resolveApprovalPolicy(),
+                    excludeTurns: true,
+                    persistExtendedHistory: true,
+                });
+                this.loadedThreadId = this.threadId;
+                this.rememberResolvedModel(resumed);
+            }
+            if (!this.threadId) {
+                const started = await this.sendRequest('thread/start', {
+                    cwd: this.cwd,
+                    ...(this.model ? { model: this.model } : {}),
+                    ...(this.sandbox ? { sandbox: this.sandbox } : {}),
+                    ...this.configPayload(),
+                    approvalPolicy: this.resolveApprovalPolicy(),
+                    experimentalRawEvents: false,
+                    persistExtendedHistory: true,
+                });
+                const threadId = readString(started.thread, 'id');
+                if (!threadId)
+                    throw new Error('Codex app-server did not return a thread id');
+                this.threadId = threadId;
+                this.loadedThreadId = threadId;
+                this.rememberResolvedModel(started);
+                onEvent({ type: 'thread.started', threadId });
+            }
+            const planModel = this.model ?? this.resolvedModel;
+            const turnPromise = new Promise((resolve, reject) => {
+                this.currentTurnResolve = resolve;
+                this.currentTurnReject = reject;
+            });
+            turnPromise.catch(() => { });
+            const turnStarted = await this.sendRequest('turn/start', {
+                threadId: this.threadId,
+                input: [
+                    { type: 'text', text: prompt, text_elements: [] },
+                    ...imagePaths.map((path) => ({ type: 'localImage', path })),
+                ],
+                ...(this.model ? { model: this.model } : {}),
+                ...this.sandboxPolicyPayload(_extraAddDirs),
+                ...(options.planMode
+                    ? {
+                        collaborationMode: {
+                            mode: 'plan',
+                            settings: {
+                                ...(planModel ? { model: planModel } : {}),
+                                reasoning_effort: null,
+                                developer_instructions: null,
+                            },
+                        },
+                    }
+                    : {}),
+            });
+            const turn = turnStarted.turn;
+            if (this.currentTurnResolve) {
+                this.currentTurnId = readString(turn, 'id') ?? null;
+                onEvent({ type: 'turn.started' });
+            }
+            return await turnPromise;
+        }
+        catch (error) {
+            this.clearActiveTurn();
+            throw error;
+        }
+    }
+    resolveApprovalPolicy() {
+        if (this.bypassApprovalsAndSandbox || this.fullAuto)
+            return 'never';
+        return this.legacyApprovalPolicy;
+    }
+    configPayload() {
+        const config = {};
+        for (const raw of this.configOverrides) {
+            const separator = raw.indexOf('=');
+            if (separator <= 0)
+                continue;
+            const key = raw.slice(0, separator).trim();
+            if (!key)
+                continue;
+            config[key] = parseConfigValue(raw.slice(separator + 1));
+        }
+        return Object.keys(config).length > 0 ? { config } : {};
+    }
+    rememberResolvedModel(result) {
+        const thread = result.thread;
+        this.resolvedModel = readString(thread, 'model') ?? readString(result, 'model') ?? this.resolvedModel;
+    }
+    sandboxPolicyPayload(extraAddDirs) {
+        if (this.bypassApprovalsAndSandbox || this.sandbox === 'danger-full-access') {
+            return { sandboxPolicy: { type: 'dangerFullAccess' } };
+        }
+        if (this.sandbox === 'read-only') {
+            return { sandboxPolicy: { type: 'readOnly', networkAccess: true } };
+        }
+        if (this.sandbox !== 'workspace-write')
+            return {};
+        const writableRoots = this.buildWritableRoots(extraAddDirs);
+        return {
+            sandboxPolicy: {
+                type: 'workspaceWrite',
+                writableRoots,
+                networkAccess: true,
+                excludeTmpdirEnvVar: false,
+                excludeSlashTmp: false,
+            },
+        };
+    }
+    buildWritableRoots(extraAddDirs) {
+        const seen = new Set();
+        const roots = [];
+        for (const raw of [this.cwd, ...this.addDirs, ...extraAddDirs]) {
+            const value = raw.trim();
+            if (!value || seen.has(value))
+                continue;
+            seen.add(value);
+            roots.push(value);
+        }
+        return roots;
+    }
+    async ensureStarted() {
+        if (this.child && this.initialized)
+            return;
+        const child = spawn(this.codexBin, ['app-server', '--listen', 'stdio://'], {
+            cwd: this.cwd,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        this.child = child;
+        const stdout = createInterface({ input: child.stdout });
+        const stderr = createInterface({ input: child.stderr });
+        stdout.on('line', (line) => this.handleLine(line));
+        stderr.on('line', (line) => {
+            const trimmed = line.trim();
+            if (trimmed)
+                this.currentOnLog?.(trimmed);
+        });
+        child.on('close', (code) => {
+            const message = `Codex app-server exited${code === null ? '' : ` with code ${code}`}`;
+            this.initialized = false;
+            this.child = null;
+            for (const pending of this.pending.values()) {
+                pending.reject(new Error(message));
+            }
+            this.pending.clear();
+            if (this.currentTurnReject)
+                this.currentTurnReject(new Error(message));
+            this.clearActiveTurn();
+        });
+        child.on('error', (error) => {
+            if (this.currentTurnReject)
+                this.currentTurnReject(error);
+        });
+        await this.sendRequest('initialize', {
+            clientInfo: { name: 'canon-codex', version: '0.0.0' },
+            capabilities: { experimentalApi: true, supportsServerRequests: true },
+        });
+        this.initialized = true;
+    }
+    handleLine(line) {
+        const message = parseJson(line);
+        if (!message)
+            return;
+        if ('id' in message && ('result' in message || 'error' in message) && !('method' in message)) {
+            const id = Number(message.id);
+            const pending = this.pending.get(id);
+            if (!pending)
+                return;
+            this.pending.delete(id);
+            if (message.error) {
+                pending.reject(new Error(stringifyPreview(message.error)));
+            }
+            else {
+                pending.resolve(message.result);
+            }
+            return;
+        }
+        if ('id' in message && typeof message.method === 'string') {
+            void this.handleServerRequest(message);
+            return;
+        }
+        if (typeof message.method === 'string') {
+            this.handleNotification(message.method, (message.params ?? {}));
+        }
+    }
+    async handleServerRequest(request) {
+        try {
+            const result = this.currentRequestHandler
+                ? await this.currentRequestHandler({
+                    id: request.id,
+                    method: request.method,
+                    params: isRecord(request.params) ? request.params : {},
+                })
+                : defaultServerRequestResult(request.method);
+            this.write({ id: request.id, result });
+        }
+        catch (error) {
+            this.write({
+                id: request.id,
+                error: {
+                    code: -32000,
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    handleNotification(method, params) {
+        if (method === 'turn/started') {
+            this.currentTurnId = readString(params.turn, 'id') ?? this.currentTurnId;
+            this.currentOnEvent?.({ type: 'turn.started' });
+            return;
+        }
+        if (method === 'thread/status/changed') {
+            const status = params.status;
+            if (status?.type === 'active' && Array.isArray(status.activeFlags)) {
+                const flags = status.activeFlags.map(String);
+                if (flags.includes('waitingOnApproval') || flags.includes('waitingOnUserInput')) {
+                    this.currentOnEvent?.({ type: 'waiting', reason: flags.join(', ') });
+                }
+            }
+            return;
+        }
+        if (method === 'item/agentMessage/delta') {
+            const itemId = readString(params, 'itemId') ?? 'agent-message';
+            const delta = readString(params, 'delta') ?? '';
+            const next = `${this.messageTextByItem.get(itemId) ?? ''}${delta}`;
+            this.messageTextByItem.set(itemId, next);
+            this.currentFinalMessage = next.trim() || this.currentFinalMessage;
+            if (next.trim())
+                this.currentOnEvent?.({ type: 'message', text: next });
+            return;
+        }
+        if (method === 'turn/plan/updated') {
+            this.planText = renderPlan(params);
+            this.currentFinalMessage = this.planText || this.currentFinalMessage;
+            if (this.planText)
+                this.currentOnEvent?.({ type: 'plan.updated', text: this.planText });
+            return;
+        }
+        if (method === 'item/plan/delta') {
+            const delta = readString(params, 'delta') ?? '';
+            this.planText = `${this.planText}${delta}`;
+            this.currentFinalMessage = this.planText.trim() || this.currentFinalMessage;
+            if (this.planText.trim())
+                this.currentOnEvent?.({ type: 'plan.updated', text: this.planText });
+            return;
+        }
+        if (method === 'item/started') {
+            const item = params.item;
+            const summary = summarizeItem(item);
+            if (summary)
+                this.currentOnEvent?.({ type: 'command.started', command: summary });
+            return;
+        }
+        if (method === 'item/completed') {
+            const item = params.item;
+            if (item?.type === 'agentMessage') {
+                const text = readString(item, 'text');
+                if (text) {
+                    this.currentFinalMessage = text;
+                    this.currentOnEvent?.({ type: 'message', text });
+                }
+            }
+            else if (item?.type === 'commandExecution') {
+                this.currentOnEvent?.({
+                    type: 'command.completed',
+                    command: readString(item, 'command') ?? 'Command',
+                    output: readString(item, 'aggregatedOutput') ?? '',
+                    exitCode: typeof item.exitCode === 'number' ? item.exitCode : null,
+                });
+            }
+            return;
+        }
+        if (method === 'turn/completed') {
+            const turn = params.turn;
+            const status = turn?.status;
+            if (isRecord(status) && status.type === 'failed') {
+                this.currentErrorText = stringifyPreview(turn?.error);
+            }
+            this.currentOnEvent?.({ type: 'turn.completed' });
+            this.resolveCurrentTurn();
+            return;
+        }
+        if (method === 'error') {
+            this.currentErrorText = stringifyPreview(params);
+        }
+    }
+    resolveCurrentTurn() {
+        const result = {
+            threadId: this.threadId,
+            finalMessage: this.currentFinalMessage,
+            exitCode: this.currentErrorText ? 1 : 0,
+            interrupted: this.interrupted,
+            errorText: this.interrupted ? null : this.currentErrorText,
+        };
+        this.currentTurnResolve?.(result);
+        this.clearActiveTurn();
+    }
+    clearActiveTurn() {
+        this.currentTurnId = null;
+        this.currentOnEvent = null;
+        this.currentOnLog = null;
+        this.currentRequestHandler = null;
+        this.currentTurnResolve = null;
+        this.currentTurnReject = null;
+        this.currentFinalMessage = null;
+        this.currentErrorText = null;
+        this.messageTextByItem.clear();
+        this.planText = '';
+    }
+    sendRequest(method, params) {
+        const id = this.requestSeq++;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            try {
+                this.write({ id, method, params });
+            }
+            catch (error) {
+                this.pending.delete(id);
+                reject(error);
+            }
+        });
+    }
+    write(message) {
+        if (!this.child)
+            throw new Error('Codex app-server is not running');
+        this.child.stdin.write(`${JSON.stringify(message)}\n`);
+    }
+}
+function parseJson(line) {
+    try {
+        const parsed = JSON.parse(line);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function readString(record, key) {
+    const value = record?.[key];
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function stringifyPreview(value) {
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value ?? {});
+    }
+    catch {
+        return String(value);
+    }
+}
+function parseConfigValue(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return '';
+    if (trimmed === 'true')
+        return true;
+    if (trimmed === 'false')
+        return false;
+    if (trimmed === 'null')
+        return null;
+    const parsedNumber = Number(trimmed);
+    if (Number.isFinite(parsedNumber) && String(parsedNumber) === trimmed)
+        return parsedNumber;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return value;
+    }
+}
+function summarizeItem(item) {
+    if (!item)
+        return null;
+    if (item.type === 'commandExecution')
+        return readString(item, 'command') ?? 'Running a command';
+    if (item.type === 'fileChange')
+        return 'Applying file changes';
+    if (item.type === 'mcpToolCall')
+        return `Calling ${readString(item, 'tool') ?? 'MCP tool'}`;
+    if (item.type === 'webSearch')
+        return 'Searching the web';
+    return null;
+}
+function renderPlan(params) {
+    const explanation = readString(params, 'explanation');
+    const plan = Array.isArray(params.plan) ? params.plan : [];
+    const lines = [
+        explanation ? `**Plan**\n${explanation}` : '**Plan**',
+        ...plan.flatMap((entry, index) => {
+            if (!isRecord(entry))
+                return [];
+            const step = readString(entry, 'step');
+            if (!step)
+                return [];
+            const status = readString(entry, 'status') ?? 'pending';
+            const marker = status === 'completed' ? '[x]' : status === 'inProgress' ? '[~]' : '[ ]';
+            return [`${index + 1}. ${marker} ${step}`];
+        }),
+    ];
+    return lines.join('\n');
+}
+function defaultServerRequestResult(method) {
+    if (method.includes('requestApproval'))
+        return { decision: 'decline' };
+    if (method === 'item/tool/requestUserInput')
+        return { answers: {} };
+    return {};
+}

package/dist/host.js

@@ -1,12 +1,15 @@
 #!/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, materializeMessageMedia, materializeReplyContextMedia, } from '@canonmsg/agent-sdk';
-import { RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildCanonHostPrompt, buildConfiguredWorkspaceOptionsWithRoots, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, createConversationMetadataLoader, createRuntimeStatePublisher, EXECUTION_ENVIRONMENT_MODES, ExecutionEnvironmentError, CanonClient, CanonStream, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, FINAL_MESSAGE_HANDOFF_MS, getActiveProfileLock, initRTDBAuth, buildLocalRuntimeId, heartbeatLocalRuntimeEntry, loadRuntimeSessionState, markLocalRuntimeStopped, normalizeTurnMetadata, normalizeTurnState, prepareConversationEnvironment, loadHostSessionConfig, releaseConversationEnvironment, resolveCanonAgent, rtdbRead, rtdbWrite, shouldTriggerAgentTurn, saveRuntimeSessionState, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, resolveHostWorkspaceCwd, upsertLocalRuntimeEntry, } from '@canonmsg/core';
+import { RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildPlanApprovalRequest, buildCanonHostPrompt, buildConfiguredWorkspaceOptionsWithRoots, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, createConversationMetadataLoader, createRuntimeStatePublisher, EXECUTION_ENVIRONMENT_MODES, ExecutionEnvironmentError, CanonClient, CanonStream, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, FINAL_MESSAGE_HANDOFF_MS, getActiveProfileLock, initRTDBAuth, buildLocalRuntimeId, heartbeatLocalRuntimeEntry, loadRuntimeSessionState, markLocalRuntimeStopped, normalizeTurnMetadata, prepareConversationEnvironment, loadHostSessionConfig, releaseConversationEnvironment, resolveCanonAgent, rtdbRead, rtdbWrite, shouldTriggerAgentTurn, saveRuntimeSessionState, buildBoundedTurnTrail, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, resolveHostWorkspaceCwd, upsertLocalRuntimeEntry, } from '@canonmsg/core';
 import { buildInboundContextLines, decideAutoReply, } from './inbound-policy.js';
 import { CodexConversationAdapter, } from './adapter.js';
+import { CodexAppServerAdapter } from './app-server-adapter.js';
+import { mapCanonApprovalResultToCodexDecision, mapCodexAppServerApprovalRequest, } from './app-server-approval.js';
 import { clearStoredThreadId, buildCodexThreadPolicyFingerprint, loadStoredThreadId, saveStoredThreadId, } from './session-store.js';
 import { deriveCodexPermissionEnvelope, mapCanonPermissionToCodex, } from './permission-mode.js';
 import { detectCodexCliVersion } from './codex-cli-version.js';
@@ -64,6 +67,19 @@ let workspaceRoots = [];
 let workspaceRootMetadata = [];
 function buildCodexRuntimeDescriptor(input) {
     const commands = [
+        ...(input.supportsPlanMode
+            ? [{
+                    id: 'plan',
+                    label: 'Plan first',
+                    description: 'Ask Codex to plan before implementing. Text after /plan becomes the planning prompt.',
+                    aliases: ['plan'],
+                    category: 'plan',
+                    placements: ['composer_slash', 'command_palette'],
+                    availability: ['always'],
+                    trailingTextBehavior: 'send_as_prompt',
+                    dispatch: { kind: 'text_passthrough', template: '/plan {argument}' },
+                }]
+            : []),
         {
             id: 'runtime-status',
             label: 'Runtime status',
@@ -79,6 +95,8 @@ function buildCodexRuntimeDescriptor(input) {
             ...RUNTIME_NEW_SESSION_ACTION,
             primitive: 'session.new',
         },
+        RUNTIME_STOP_ACTION,
+        RUNTIME_STOP_AND_DROP_ACTION,
     ];
     const descriptor = buildFirstPartyCodingRuntimeDescriptor({
         clientType: 'codex',
@@ -91,11 +109,6 @@ function buildCodexRuntimeDescriptor(input) {
         presentation: input.presentation,
         streamingTextMode: 'snapshot',
         commands,
-        actions: [
-            RUNTIME_STOP_ACTION,
-            RUNTIME_STOP_AND_DROP_ACTION,
-            RUNTIME_NEW_SESSION_ACTION,
-        ],
     });
     if (input.models.length > 0) {
         return descriptor;
@@ -119,18 +132,6 @@ function buildCodexModelOptions(model) {
         ? [{ value: model.trim(), label: modelOptionLabel(model.trim()) }]
         : [];
 }
-function normalizeRuntimeTurnState(value) {
-    const normalizedTurn = normalizeTurnState(value);
-    if (normalizedTurn) {
-        return {
-            state: normalizedTurn.state,
-            ...(normalizedTurn.openedAt !== undefined ? { openedAt: normalizedTurn.openedAt } : {}),
-            ...(normalizedTurn.updatedAt !== undefined ? { updatedAt: normalizedTurn.updatedAt } : {}),
-            ...(normalizedTurn.turnUpdatedAt !== undefined ? { turnUpdatedAt: normalizedTurn.turnUpdatedAt } : {}),
-        };
-    }
-    return null;
-}
 async function publishAgentRuntime(agentId, runtime) {
     await publishHostAgentRuntime(agentId, 'codex', runtime);
 }
@@ -249,6 +250,78 @@ 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'))
+        return { planMode: false, content };
+    const rest = trimmed.replace(/^\/plan(?:\s+)?/i, '').trim();
+    return {
+        planMode: true,
+        content: rest || 'Please inspect the request and propose a plan before making changes.',
+    };
+}
+function mapCodexQuestions(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const questions = value.slice(0, 12).flatMap((entry) => {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            return [];
+        const record = entry;
+        const id = typeof record.id === 'string' && record.id.trim() ? record.id.trim().slice(0, 120) : null;
+        const question = typeof record.question === 'string' && record.question.trim()
+            ? record.question.trim().slice(0, 1000)
+            : null;
+        if (!id || !/^[A-Za-z0-9_.:-]{1,120}$/.test(id) || !question)
+            return [];
+        const header = typeof record.header === 'string' && record.header.trim()
+            ? record.header.trim().slice(0, 120)
+            : undefined;
+        const rawOptions = Array.isArray(record.options) ? record.options : [];
+        const choices = rawOptions.slice(0, 12).flatMap((option) => {
+            if (!option || typeof option !== 'object' || Array.isArray(option))
+                return [];
+            const optionRecord = option;
+            const label = typeof optionRecord.label === 'string' && optionRecord.label.trim()
+                ? optionRecord.label.trim().slice(0, 120)
+                : null;
+            if (!label)
+                return [];
+            const description = typeof optionRecord.description === 'string' && optionRecord.description.trim()
+                ? optionRecord.description.trim().slice(0, 300)
+                : undefined;
+            return [{ label, value: label, ...(description ? { description } : {}) }];
+        });
+        return [{
+                id,
+                question,
+                ...(header ? { header } : {}),
+                ...(choices.length > 0 ? { choices } : {}),
+                ...(choices.length > 0 && record.allowOther !== false ? { allowOther: true } : {}),
+                ...(record.allowOther === true || record.isOther === true ? { allowOther: true } : {}),
+                ...(record.isSecret === true ? { isSecret: true } : {}),
+                ...(record.multiSelect === true ? { multiSelect: true } : {}),
+            }];
+    });
+    return questions.length > 0 ? questions : undefined;
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function readString(record, key) {
+    const value = record[key];
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
 export async function main() {
     setDefaultResultOrder('ipv4first');
     const { values: args } = parseArgs({
@@ -290,12 +363,14 @@ 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 { apiKey, agentId: profileAgentId, agentName: profileAgentName, profile, baseUrl, lockHandle, } = resolveCanonAgent({ logPrefix: '[canon-codex]', expectedClientType: 'codex' });
     console.error(`[canon-codex] Starting${profile ? ` (profile: ${profile})` : ''} in ${workingDir}`);
     const client = new CanonClient(apiKey, baseUrl);
@@ -418,14 +493,6 @@ export async function main() {
             pendingMembershipChanges.delete(conversationId);
         }
     }
-    async function loadSenderRuntimeState(conversationId, senderId) {
-        try {
-            return normalizeRuntimeTurnState(await rtdbRead(`/turn-state/${conversationId}/${senderId}`));
-        }
-        catch {
-            return null;
-        }
-    }
     async function loadHydratedInboundContext(input) {
         const [conversation, page] = await Promise.all([
             getConversationMeta(input.conversationId),
@@ -523,6 +590,61 @@ export async function main() {
     function clearStreaming(conversationId) {
         runtimeState.clearStreaming(conversationId).catch(() => { });
     }
+    function writeCodexStreaming(session, text, status) {
+        if (text !== null) {
+            session.turnLiveText = text;
+        }
+        else if (status !== 'thinking' && session.turnLiveText === 'Thinking…') {
+            session.turnLiveText = '';
+        }
+        runtimeState.writeStreaming(session.conversationId, {
+            text: session.turnLiveText,
+            status,
+            messageId: session.currentTurnId ?? undefined,
+            turnId: session.currentTurnId,
+            blocks: session.turnBlocks,
+        }).catch(() => { });
+    }
+    function upsertTurnBlock(session, block) {
+        const now = Date.now();
+        const index = session.turnBlocks.findIndex((existing) => existing.id === block.id);
+        const existing = index >= 0 ? session.turnBlocks[index] : null;
+        const next = {
+            ...(existing ?? {
+                sequence: session.turnBlocks.length + 1,
+                createdAt: now,
+            }),
+            ...block,
+            turnId: session.currentTurnId ?? block.id,
+            updatedAt: now,
+        };
+        session.turnBlocks = index >= 0
+            ? [
+                ...session.turnBlocks.slice(0, index),
+                next,
+                ...session.turnBlocks.slice(index + 1),
+            ]
+            : [...session.turnBlocks, next];
+    }
+    function completeTurnBlock(session, id, summary) {
+        const existing = session.turnBlocks.find((block) => block.id === id);
+        if (!existing)
+            return;
+        upsertTurnBlock(session, {
+            id,
+            kind: existing.kind,
+            status: 'completed',
+            title: existing.title,
+            text: existing.text,
+            summary: summary ?? existing.summary,
+        });
+    }
+    function buildFinalTurnTrail(session) {
+        return buildBoundedTurnTrail(session.turnBlocks.map((block) => ({
+            ...block,
+            turnId: session.currentTurnId ?? block.turnId,
+        })));
+    }
     async function handoffFinalMessage(conversationId) {
         await sleep(FINAL_MESSAGE_HANDOFF_MS);
         clearStreaming(conversationId);
@@ -555,6 +677,9 @@ export async function main() {
             return;
         session.closed = true;
         stopVisibleWorkSignal(session);
+        if ('close' in session.adapter && typeof session.adapter.close === 'function') {
+            session.adapter.close();
+        }
         releaseConversationEnvironment(session.environment);
         clearStreaming(conversationId);
         runtimeState.clearSessionState(conversationId).catch(() => { });
@@ -638,11 +763,20 @@ export async function main() {
                     throw new ExecutionEnvironmentError(modelGuard, modelGuard);
                 }
                 const storedThreadId = loadStoredThreadId(runtimeId, agentId, conversationId, environment.baseCwd, environment.mode, policy.fingerprint);
-                const session = {
-                    conversationId,
-                    cwd: sessionCwd,
-                    environment,
-                    adapter: new CodexConversationAdapter({
+                const adapter = useAppServer
+                    ? new CodexAppServerAdapter({
+                        cwd: sessionCwd,
+                        threadId: storedThreadId,
+                        codexBin,
+                        model: policy.model ?? null,
+                        sandbox: policy.sandbox,
+                        approvalPolicy: policy.approvalPolicy,
+                        addDirs: args['add-dir'] ?? [],
+                        configOverrides: args.config ?? [],
+                        fullAuto: policy.fullAuto,
+                        bypassApprovalsAndSandbox: policy.bypassApprovalsAndSandbox,
+                    })
+                    : new CodexConversationAdapter({
                         cwd: sessionCwd,
                         threadId: storedThreadId,
                         codexBin,
@@ -654,7 +788,12 @@ export async function main() {
                         configOverrides: args.config ?? [],
                         fullAuto: policy.fullAuto,
                         bypassApprovalsAndSandbox: policy.bypassApprovalsAndSandbox,
-                    }),
+                    });
+                const session = {
+                    conversationId,
+                    cwd: sessionCwd,
+                    environment,
+                    adapter,
                     queue: [],
                     running: false,
                     state: {
@@ -673,6 +812,8 @@ export async function main() {
                     lastActivity: Date.now(),
                     typingKeepaliveTimer: null,
                     closed: false,
+                    turnLiveText: '',
+                    turnBlocks: [],
                 };
                 sessions.set(conversationId, session);
                 await Promise.all([
@@ -697,8 +838,8 @@ export async function main() {
             pendingSessionCreations.delete(conversationId);
         }
     }
-    function enqueuePrompt(session, prompt, intent = 'queue', toFront = false, sourceMessageId, markAccepted = false, imagePaths = [], mediaAddDirs = []) {
-        const nextPrompt = { prompt, intent, sourceMessageId, markAccepted, imagePaths, mediaAddDirs };
+    function enqueuePrompt(session, prompt, intent = 'queue', toFront = false, sourceMessageId, markAccepted = false, imagePaths = [], mediaAddDirs = [], planMode = false) {
+        const nextPrompt = { prompt, intent, sourceMessageId, markAccepted, imagePaths, mediaAddDirs, planMode };
         if (toFront) {
             session.queue.unshift(nextPrompt);
         }
@@ -709,8 +850,145 @@ export async function main() {
         writeTurn(session);
         void runNextTurn(session);
     }
+    async function waitForRuntimeInputResponse(input) {
+        while (Date.now() < input.expiresAt) {
+            const response = await client.consumeRuntimeInputResponse({
+                conversationId: input.conversationId,
+                inputId: input.inputId,
+            }).catch(() => null);
+            if (response?.status === 'submitted') {
+                return { status: 'submitted', value: response.value, answers: response.answers };
+            }
+            if (response?.status === 'cancelled' || response?.status === 'timeout') {
+                return { status: response.status };
+            }
+            await sleep(1_000);
+        }
+        const response = await client.consumeRuntimeInputResponse({
+            conversationId: input.conversationId,
+            inputId: input.inputId,
+        }).catch(() => null);
+        if (response?.status === 'submitted') {
+            return { status: 'submitted', value: response.value, answers: response.answers };
+        }
+        return { status: 'timeout' };
+    }
+    async function waitForRuntimeApprovalResponse(input) {
+        while (Date.now() < input.expiresAt) {
+            const response = await client.consumeRuntimeApprovalResponse({
+                conversationId: input.conversationId,
+                approvalId: input.approvalId,
+            }).catch(() => null);
+            if (response?.status === 'allow') {
+                return { decision: 'allow', sessionRule: response.sessionRule };
+            }
+            if (response?.status === 'deny' || response?.status === 'timeout') {
+                return { decision: 'deny' };
+            }
+            await sleep(1_000);
+        }
+        await client.consumeRuntimeApprovalResponse({
+            conversationId: input.conversationId,
+            approvalId: input.approvalId,
+        }).catch(() => null);
+        return { decision: 'deny' };
+    }
+    async function handleCodexServerRequest(session, request) {
+        const requestId = String(request.id);
+        const params = request.params;
+        const expiresAt = Date.now() + 30 * 60_000;
+        if (request.method === 'item/tool/requestUserInput') {
+            const paramsInput = isRecord(params.input) ? params.input : null;
+            const paramsArguments = isRecord(params.arguments) ? params.arguments : null;
+            const questions = mapCodexQuestions(params.questions ?? paramsInput?.questions ?? paramsArguments?.questions);
+            const inputId = readString(params, 'itemId') ?? requestId;
+            await client.createRuntimeInputRequest({
+                conversationId: session.conversationId,
+                inputId,
+                kind: 'clarify',
+                expiresAt,
+                responseUserId: ownerId ?? undefined,
+                title: 'Codex needs input',
+                prompt: questions?.length
+                    ? 'Codex needs your input to continue.'
+                    : 'Codex needs input.',
+                ...(questions ? { questions } : {}),
+                sensitive: Boolean(questions?.some((question) => question.isSecret)),
+                native: {
+                    runtime: 'codex',
+                    method: request.method,
+                    requestId,
+                    turnId: readString(params, 'turnId') ?? session.currentTurnId ?? undefined,
+                    handles: {
+                        itemId: readString(params, 'itemId') ?? '',
+                        threadId: readString(params, 'threadId') ?? '',
+                    },
+                },
+                turnId: session.currentTurnId ?? undefined,
+            });
+            const response = await waitForRuntimeInputResponse({
+                conversationId: session.conversationId,
+                inputId,
+                expiresAt,
+            });
+            return { answers: response.status === 'submitted' ? response.answers ?? {} : {} };
+        }
+        const mappedApproval = mapCodexAppServerApprovalRequest({
+            method: request.method,
+            params,
+        });
+        if (mappedApproval) {
+            const approvalId = readString(params, 'approvalId') ?? readString(params, 'itemId') ?? requestId;
+            await client.createRuntimeApprovalRequest({
+                conversationId: session.conversationId,
+                approvalId,
+                toolName: mappedApproval.toolName,
+                toolSummary: mappedApproval.toolSummary,
+                category: mappedApproval.category,
+                risk: mappedApproval.risk,
+                riskLevel: mappedApproval.riskLevel,
+                native: {
+                    ...mappedApproval.native,
+                    requestId,
+                    method: request.method,
+                },
+                details: mappedApproval.details,
+                responseUserId: ownerId ?? undefined,
+                allowSessionRule: true,
+                expiresAt,
+                turnId: session.currentTurnId ?? undefined,
+            });
+            const response = await waitForRuntimeApprovalResponse({
+                conversationId: session.conversationId,
+                approvalId,
+                expiresAt,
+            });
+            if (request.method === 'item/permissions/requestApproval') {
+                return response.decision === 'allow'
+                    ? { permissions: isRecord(params.permissions) ? params.permissions : {}, scope: response.sessionRule ? 'session' : 'turn' }
+                    : { permissions: {}, scope: 'turn' };
+            }
+            return mapCanonApprovalResultToCodexDecision({
+                decision: response.decision,
+                ...(response.sessionRule ? { sessionRule: response.sessionRule } : {}),
+            });
+        }
+        return {};
+    }
     async function enqueueInboundMessage(input) {
         knownConversationIds.add(input.conversationId);
+        if (isRecord(input.message.metadata)
+            && input.message.metadata.type === 'plan_approval_reply'
+            && typeof input.message.metadata.decision === 'string') {
+            const session = await getOrCreateSession(input.conversationId);
+            const feedback = readString(input.message.metadata, 'feedback');
+            const decision = input.message.metadata.decision;
+            const prompt = decision === 'approve'
+                ? 'The plan was approved. Implement the approved plan now.'
+                : `Please revise the plan.${feedback ? `\n\nRevision feedback:\n${feedback}` : ''}`;
+            enqueuePrompt(session, prompt, 'queue', false, input.message.id, false, [], [], decision !== 'approve');
+            return;
+        }
         let materialized = [];
         if (input.message.id) {
             try {
@@ -723,7 +1001,11 @@ export async function main() {
                 console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Failed to materialize media:`, error instanceof Error ? error.message : error);
             }
         }
-        const content = renderInboundContent(input.message, materialized);
+        const renderedContent = renderInboundContent(input.message, materialized);
+        const planCommand = useAppServer
+            ? parsePlanCommand(renderedContent)
+            : { planMode: false, content: renderedContent };
+        const content = planCommand.content;
         const hydrated = await loadHydratedInboundContext({
             conversationId: input.conversationId,
             message: input.message,
@@ -773,7 +1055,6 @@ export async function main() {
                 ...(activeSelfContextId ? { selfContextId: activeSelfContextId } : {}),
                 metadata: {
                     turnSemantics: 'turn_complete',
-                    turnComplete: true,
                     replyBehavior: 'suppress_auto_reply',
                 },
             }).catch(() => { });
@@ -789,14 +1070,14 @@ export async function main() {
             replyContext,
         });
         if (session.running && deliveryIntent === 'interrupt') {
-            enqueuePrompt(session, prompt, deliveryIntent, true, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs);
+            enqueuePrompt(session, prompt, deliveryIntent, true, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode);
             console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Interrupting current turn for explicit human send-now`);
             await session.adapter.interrupt().catch(() => { });
             clearStreaming(input.conversationId);
             client.setTyping(input.conversationId, false).catch(() => { });
             return;
         }
-        enqueuePrompt(session, prompt, deliveryIntent, false, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs);
+        enqueuePrompt(session, prompt, deliveryIntent, false, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode);
     }
     async function runNextTurn(session) {
         if (session.running || session.closed)
@@ -808,6 +1089,8 @@ export async function main() {
         session.state.lastError = undefined;
         session.state.state = 'running';
         session.currentTurnId = randomUUID();
+        session.turnLiveText = '';
+        session.turnBlocks = [];
         session.currentTurnOpenedAt = Date.now();
         session.currentTurnUpdatedAt = session.currentTurnOpenedAt;
         session.lastAcceptedIntent = nextTurn.intent;
@@ -817,10 +1100,7 @@ export async function main() {
         writeState(session);
         writeTurn(session);
         startVisibleWorkSignal(session);
-        runtimeState.writeStreaming(session.conversationId, {
-            text: 'Thinking…',
-            status: 'thinking',
-        }).catch(() => { });
+        writeCodexStreaming(session, 'Thinking…', 'thinking');
         try {
             const modelGuard = buildCodexModelGuardMessage(session.state.model, codexCliStatus);
             if (modelGuard) {
@@ -844,10 +1124,31 @@ export async function main() {
                     writeTurn(session);
                     stopVisibleWorkSignal(session);
                     client.setTyping(session.conversationId, false).catch(() => { });
-                    runtimeState.writeStreaming(session.conversationId, {
+                    writeCodexStreaming(session, event.text, 'streaming');
+                    return;
+                }
+                if (event.type === 'plan.updated') {
+                    session.turnState = 'streaming';
+                    markTurnProgress(session);
+                    writeTurn(session);
+                    stopVisibleWorkSignal(session);
+                    client.setTyping(session.conversationId, false).catch(() => { });
+                    upsertTurnBlock(session, {
+                        id: `plan:${session.currentTurnId}`,
+                        kind: 'plan',
+                        status: 'running',
+                        title: 'Plan',
                         text: event.text,
-                        status: 'streaming',
-                    }).catch(() => { });
+                    });
+                    writeCodexStreaming(session, event.text, 'streaming');
+                    return;
+                }
+                if (event.type === 'waiting') {
+                    session.turnState = 'waiting_input';
+                    markTurnProgress(session);
+                    writeTurn(session);
+                    stopVisibleWorkSignal(session);
+                    writeCodexStreaming(session, null, 'waiting_input');
                     return;
                 }
                 if (event.type === 'command.started') {
@@ -855,18 +1156,24 @@ export async function main() {
                     markTurnProgress(session);
                     writeTurn(session);
                     startVisibleWorkSignal(session);
-                    runtimeState.writeStreaming(session.conversationId, {
-                        text: summarizeCommand(event.command),
-                        status: 'tool',
-                    }).catch(() => { });
+                    upsertTurnBlock(session, {
+                        id: `command:${session.currentTurnId}`,
+                        kind: 'tool',
+                        status: 'running',
+                        title: summarizeCommand(event.command),
+                        summary: 'Command running',
+                    });
+                    writeCodexStreaming(session, null, 'tool');
                     return;
                 }
                 if (event.type === 'command.completed') {
+                    completeTurnBlock(session, `command:${session.currentTurnId}`, 'Command completed');
                     if (session.turnState === 'tool') {
                         session.turnState = 'thinking';
                         markTurnProgress(session);
                         writeTurn(session);
                         startVisibleWorkSignal(session);
+                        writeCodexStreaming(session, null, 'thinking');
                     }
                     return;
                 }
@@ -881,7 +1188,10 @@ export async function main() {
                 clearStoredThreadId(runtimeId, agentId, session.conversationId, session.environment.baseCwd, session.environment.mode);
                 session.adapter.clearThreadId();
             };
-            const runTurnOnce = () => session.adapter.runTurn(nextTurn.prompt, handleCodexEvent, logCodexLine, turnImagePaths, turnMediaAddDirs);
+            const runTurnOnce = () => session.adapter.runTurn(nextTurn.prompt, handleCodexEvent, logCodexLine, turnImagePaths, turnMediaAddDirs, {
+                planMode: nextTurn.planMode,
+                onServerRequest: (request) => handleCodexServerRequest(session, request),
+            });
             let result = await runTurnOnce();
             if (!result.interrupted
                 && !result.finalMessage
@@ -895,10 +1205,28 @@ export async function main() {
             if (result.threadId && !session.resetRequested) {
                 saveStoredThreadId(runtimeId, agentId, session.conversationId, session.environment.baseCwd, result.threadId, session.environment.mode, session.policyFingerprint);
             }
-            if (!result.interrupted && result.finalMessage) {
+            if (!result.interrupted && result.finalMessage && nextTurn.planMode) {
+                const planApproval = buildPlanApprovalRequest(session.currentTurnId ?? randomUUID(), 'Plan ready for review.', {
+                    responseUserId: ownerId ?? undefined,
+                    title: 'Codex Plan',
+                    body: result.finalMessage,
+                });
+                await client.sendMessage(session.conversationId, planApproval.text, {
+                    metadata: {
+                        ...planApproval.metadata,
+                        turnId: session.currentTurnId,
+                        turnSemantics: 'control',
+                        replyBehavior: 'suppress_auto_reply',
+                    },
+                });
+                await handoffFinalMessage(session.conversationId);
+                console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Sent plan approval card`);
+            }
+            else if (!result.interrupted && result.finalMessage) {
                 if (isRecoverableCodexThreadError(result.errorText)) {
                     clearStoredThread();
                 }
+                const turnTrail = buildFinalTurnTrail(session);
                 await client.sendMessage(session.conversationId, result.finalMessage, {
                     ...(session.activeSelfContextId
                         ? { selfContextId: session.activeSelfContextId }
@@ -906,8 +1234,8 @@ export async function main() {
                     metadata: {
                         turnId: session.currentTurnId,
                         turnSemantics: 'turn_complete',
-                        turnComplete: true,
                         deliveryIntent: session.lastAcceptedIntent ?? undefined,
+                        ...(turnTrail.length > 0 ? { turnTrail } : {}),
                     },
                 });
                 await handoffFinalMessage(session.conversationId);
@@ -920,6 +1248,7 @@ export async function main() {
                 if (result.errorText) {
                     console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn exited ${result.exitCode}: ${result.errorText}`);
                 }
+                const turnTrail = buildFinalTurnTrail(session);
                 await client.sendMessage(session.conversationId, userVisibleError, {
                     ...(session.activeSelfContextId
                         ? { selfContextId: session.activeSelfContextId }
@@ -927,8 +1256,8 @@ export async function main() {
                     metadata: {
                         turnId: session.currentTurnId,
                         turnSemantics: 'turn_complete',
-                        turnComplete: true,
                         deliveryIntent: session.lastAcceptedIntent ?? undefined,
+                        ...(turnTrail.length > 0 ? { turnTrail } : {}),
                     },
                 });
                 await handoffFinalMessage(session.conversationId);
@@ -958,7 +1287,6 @@ export async function main() {
                 metadata: {
                     turnId: session.currentTurnId,
                     turnSemantics: 'turn_complete',
-                    turnComplete: true,
                     deliveryIntent: session.lastAcceptedIntent ?? undefined,
                 },
             }).catch(() => { });
@@ -1018,6 +1346,7 @@ export async function main() {
             permissionModes: [...codexPermissionEnvelope.availablePermissionModes],
             defaultPermissionMode: codexPermissionEnvelope.defaultPermissionMode,
             presentation: runtimePresentation,
+            supportsPlanMode: useAppServer,
         }),
     };
     async function baselineControlSignal(conversationId) {
@@ -1102,12 +1431,14 @@ export async function main() {
                         {
                             id: 'transport',
                             label: 'Transport',
-                            value: 'exec --json',
+                            value: useAppServer ? 'app-server' : 'exec --json',
                         },
                         {
                             id: 'streaming',
                             label: 'Live output',
-                            value: 'Thinking, tools, and completed-message previews',
+                            value: useAppServer
+                                ? 'Plans, questions, approvals, tools, and message deltas'
+                                : 'Thinking, tools, and completed-message previews',
                         },
                         {
                             id: 'codex-cli',
@@ -1118,8 +1449,8 @@ export async function main() {
                         {
                             id: 'nativeActions',
                             label: 'Native actions',
-                            value: 'Limited until app-server transport',
-                            tone: 'warning',
+                            value: useAppServer ? 'Enabled' : 'Limited until app-server transport',
+                            ...(useAppServer ? {} : { tone: 'warning' }),
                         },
                     ],
                     execution: {
@@ -1133,8 +1464,9 @@ export async function main() {
                         fallbackReason: resolveExecutionFallbackReason(session?.environment),
                     },
                     notes: [
-                        'This Codex host uses the current exec --json transport, so Canon can show thinking, tool activity, and completed assistant-message previews, but not token-by-token text deltas.',
-                        'Codex review, compact/rollback, live plan/diff/reasoning updates, PTY command execution, plugin/app/MCP inventory, and structured approvals require the future app-server transport.',
+                        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.',
                     ],
                 };
                 await runtimeState.writeRuntimeInfo(conversationId, payload);
@@ -1209,6 +1541,7 @@ export async function main() {
                 permissionModes: [...codexPermissionEnvelope.availablePermissionModes],
                 defaultPermissionMode: codexPermissionEnvelope.defaultPermissionMode,
                 presentation: runtimePresentation,
+                supportsPlanMode: useAppServer,
             }),
         };
     }
@@ -1229,6 +1562,7 @@ export async function main() {
                 permissionModes: [...codexPermissionEnvelope.availablePermissionModes],
                 defaultPermissionMode: codexPermissionEnvelope.defaultPermissionMode,
                 presentation: runtimePresentation,
+                supportsPlanMode: useAppServer,
             }),
         };
     }
@@ -1258,13 +1592,9 @@ export async function main() {
                 ? inboundMessages.slice(cursorIndex + 1)
                 : inboundMessages.slice(-1);
             for (const latestMessage of messagesToRecover) {
-                const senderTurnState = latestMessage.senderType === 'ai_agent'
-                    ? await loadSenderRuntimeState(conversation.id, latestMessage.senderId)
-                    : null;
                 const triggerDecision = shouldTriggerAgentTurn({
                     senderType: latestMessage.senderType ?? 'human',
                     metadata: latestMessage.metadata,
-                    senderTurnState,
                 });
                 if (!triggerDecision.allow) {
                     console.error(`[canon-codex] [${conversation.id.slice(0, 8)}] Skipping startup recovery for suppressed message (${triggerDecision.reason})`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.11.11",
+  "version": "0.12.0",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/index.js",
@@ -29,8 +29,8 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@canonmsg/agent-sdk": "^1.6.1",
-    "@canonmsg/core": "^0.23.0"
+    "@canonmsg/agent-sdk": "^2.0.0",
+    "@canonmsg/core": "^1.0.0"
   },
   "engines": {
     "node": ">=18.0.0"