@canonmsg/codex-plugin 0.29.2 → 0.29.4

package/dist/adapter.d.ts

@@ -45,6 +45,8 @@ export interface CodexServerRequest {
     params: Record<string, unknown>;
 }
 export interface CodexRunTurnOptions {
+    /** Original human text, before Canon adds conversation/reply context. */
+    skillInvocationText?: string;
     planMode?: boolean;
     onServerRequest?: (request: CodexServerRequest) => Promise<unknown>;
 }

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

@@ -36,6 +36,7 @@ export declare class CodexAppServerAdapter {
     private threadId;
     private loadedThreadId;
     private resolvedModel;
+    private observedSettings;
     private resolvedReasoningEffort;
     private currentTurnId;
     private requestSeq;
@@ -67,6 +68,10 @@ export declare class CodexAppServerAdapter {
     });
     getThreadId(): string | null;
     getResolvedModel(): string | null;
+    getObservedSettings(): Readonly<{
+        model?: string;
+        effort?: string;
+    }>;
     getResolvedReasoningEffort(): string | null;
     clearThreadId(): void;
     setModel(model: string | null): void;

package/dist/app-server-adapter.js

@@ -17,6 +17,8 @@ export class CodexAppServerAdapter {
     threadId;
     loadedThreadId = null;
     resolvedModel = null;
+    // Public observations never inherit requested settings or fallback defaults.
+    observedSettings = {};
     resolvedReasoningEffort;
     currentTurnId = null;
     requestSeq = 1;
@@ -53,16 +55,21 @@ export class CodexAppServerAdapter {
     getResolvedModel() {
         return this.resolvedModel ?? this.model;
     }
+    getObservedSettings() {
+        return { ...this.observedSettings };
+    }
     getResolvedReasoningEffort() {
         return this.resolvedReasoningEffort ?? this.reasoningEffort;
     }
     clearThreadId() {
+        this.observedSettings = {};
         this.threadId = null;
         this.loadedThreadId = null;
         this.resolvedModel = null;
         this.resolvedReasoningEffort = this.reasoningEffort;
     }
     setModel(model) {
+        this.observedSettings = {};
         this.model = model;
         this.resolvedModel = model;
     }
@@ -78,6 +85,7 @@ export class CodexAppServerAdapter {
         const next = effort && effort.trim() ? effort.trim() : null;
         if (next === this.reasoningEffort && next === this.resolvedReasoningEffort)
             return;
+        this.observedSettings = { model: this.observedSettings.model };
         this.reasoningEffort = next;
         this.resolvedReasoningEffort = next;
         if (this.threadId && this.loadedThreadId === this.threadId) {
@@ -110,6 +118,7 @@ export class CodexAppServerAdapter {
         return await this.sendRequest(method, params);
     }
     close() {
+        this.observedSettings = {};
         this.child?.kill('SIGTERM');
         this.child = null;
         this.initialized = false;
@@ -171,7 +180,7 @@ export class CodexAppServerAdapter {
             turnPromise.catch(() => { });
             const turnStarted = await this.sendRequest('turn/start', {
                 threadId: this.threadId,
-                input: await this.buildTurnInput(prompt, imagePaths),
+                input: await this.buildTurnInput(prompt, imagePaths, options.skillInvocationText),
                 ...(this.model ? { model: this.model } : {}),
                 ...this.sandboxPolicyPayload(_extraAddDirs),
                 collaborationMode: {
@@ -216,7 +225,9 @@ export class CodexAppServerAdapter {
     }
     rememberResolvedModel(result) {
         const thread = result.thread;
-        this.resolvedModel = readString(thread, 'model') ?? readString(result, 'model') ?? this.resolvedModel;
+        const model = readString(thread, 'model') ?? readString(result, 'model');
+        this.observedSettings = { ...this.observedSettings, model: model ?? undefined };
+        this.resolvedModel = model ?? this.resolvedModel;
     }
     sandboxPolicyPayload(extraAddDirs) {
         if (this.bypassApprovalsAndSandbox || this.sandbox === 'danger-full-access') {
@@ -290,22 +301,27 @@ export class CodexAppServerAdapter {
         } while (cursor);
         return models;
     }
-    async buildTurnInput(prompt, imagePaths) {
-        const skillPrompt = parseSkillSlashPrompt(prompt);
+    async buildTurnInput(prompt, imagePaths, skillInvocationText) {
+        const skillPrompt = parseSkillSlashPrompt(skillInvocationText ?? prompt);
         const input = [];
         if (skillPrompt) {
             const skills = await this.listSkills().catch(() => []);
             const selected = skills.find((skill) => skill.name.toLowerCase() === skillPrompt.name.toLowerCase());
             if (selected) {
                 input.push({ type: 'skill', name: selected.name, path: selected.path });
-                if (skillPrompt.prompt.trim()) {
-                    input.push({ type: 'text', text: skillPrompt.prompt, text_elements: [] });
+                // Resolve the native skill from the actual message, retaining the
+                // framed prompt as context instead of parsing quoted/history text.
+                const text = skillInvocationText === undefined ? skillPrompt.prompt : prompt;
+                if (text.trim()) {
+                    input.push({ type: 'text', text, text_elements: [] });
                 }
             }
             else {
                 input.push({
                     type: 'text',
-                    text: `$${skillPrompt.name}${skillPrompt.prompt.trim() ? ` ${skillPrompt.prompt.trim()}` : ''}`,
+                    text: skillInvocationText === undefined
+                        ? `$${skillPrompt.name}${skillPrompt.prompt.trim() ? ` ${skillPrompt.prompt.trim()}` : ''}`
+                        : prompt,
                     text_elements: [],
                 });
             }
@@ -333,6 +349,7 @@ export class CodexAppServerAdapter {
                 this.currentOnLog?.(trimmed);
         });
         child.on('close', (code) => {
+            this.observedSettings = {};
             const message = `Codex app-server exited${code === null ? '' : ` with code ${code}`}`;
             this.initialized = false;
             this.child = null;
@@ -428,6 +445,7 @@ export class CodexAppServerAdapter {
             const settings = isRecord(params.threadSettings) ? params.threadSettings : {};
             const model = readString(settings, 'model') ?? null;
             const effort = readString(settings, 'effort') ?? null;
+            this.observedSettings = { model: model ?? undefined, effort: effort ?? undefined };
             this.resolvedModel = model ?? this.resolvedModel;
             this.resolvedReasoningEffort = effort;
             this.currentOnEvent?.({ type: 'settings.updated', model, effort });
@@ -435,6 +453,7 @@ export class CodexAppServerAdapter {
         }
         if (method === 'model/rerouted') {
             const model = readString(params, 'toModel') ?? null;
+            this.observedSettings = { model: model ?? undefined };
             this.resolvedModel = model ?? this.resolvedModel;
             this.currentOnEvent?.({
                 type: 'settings.updated',

package/dist/codex-app-tools.js

@@ -142,31 +142,6 @@ const CODEX_NO_REPLY_TOOL = tool(CODEX_NO_REPLY_TOOL_NAME, 'End your turn withou
     },
 }, false);
 export const CODEX_APP_DYNAMIC_TOOLS = [
-    tool('automation_update', 'Create, update, view, or delete Codex app automations. Canon exposes the name for compatibility, but does not manage Desktop automations.', {
-        type: 'object',
-        additionalProperties: false,
-        properties: {
-            id: { type: 'string' },
-            mode: { type: 'string' },
-            kind: { type: 'string' },
-            name: { type: 'string' },
-            prompt: { type: 'string' },
-            rrule: { type: 'string' },
-            cwds: {
-                anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }],
-            },
-            destination: { type: 'string' },
-            executionEnvironment: { type: 'string' },
-            localEnvironmentConfigPath: { type: ['string', 'null'] },
-            model: { type: 'string' },
-            reasoningEffort: { type: 'string' },
-            targetThreadId: { type: 'string' },
-            status: { type: 'string' },
-        },
-    }),
-    tool('navigate_to_codex_page', 'Navigate the Codex Desktop UI. Canon exposes the name for compatibility, but has no Codex Desktop page to navigate.', { type: 'object', additionalProperties: true, properties: {} }),
-    tool('read_thread_terminal', 'Read the Codex Desktop terminal output for this thread. Canon exposes the name for compatibility, but has no Desktop terminal pane.', emptyObjectSchema, false),
-    tool('load_workspace_dependencies', 'Locate bundled Desktop workspace dependency runtimes. Canon exposes the name for compatibility, but does not provide Desktop bundle paths.', emptyObjectSchema, false),
     tool('fork_thread', 'Fork a Codex thread. Omit threadId to fork the calling thread. Canon supports same-directory forks.', {
         type: 'object',
         additionalProperties: false,
@@ -175,17 +150,6 @@ export const CODEX_APP_DYNAMIC_TOOLS = [
             environment: forkEnvironmentSchema,
         },
     }),
-    tool('handoff_thread', 'Move a Codex thread between a checkout and worktree. Canon exposes the name for compatibility, but does not manage Desktop handoffs.', {
-        type: 'object',
-        additionalProperties: false,
-        properties: { threadId: { type: 'string' } },
-        required: ['threadId'],
-    }),
-    tool('get_handoff_status', 'Read Codex Desktop handoff status. Canon exposes the name for compatibility, but does not manage Desktop handoffs.', {
-        type: 'object',
-        additionalProperties: false,
-        properties: { threadId: { type: 'string' } },
-    }),
     tool('list_projects', 'List Canon workspaces available to Codex app tools.', emptyObjectSchema),
     tool('create_thread', 'Create a separate Codex thread only when the user explicitly asks for a new or separate thread. Canon supports local project targets.', {
         type: 'object',
@@ -224,15 +188,6 @@ export const CODEX_APP_DYNAMIC_TOOLS = [
         },
         required: ['threadId', 'prompt'],
     }),
-    tool('set_thread_pinned', 'Pin or unpin a Codex thread. Canon exposes the name for compatibility, but pinned state is Desktop-only.', {
-        type: 'object',
-        additionalProperties: false,
-        properties: {
-            threadId: { type: 'string' },
-            pinned: { type: 'boolean' },
-        },
-        required: ['threadId', 'pinned'],
-    }),
     tool('set_thread_archived', 'Archive or unarchive a Codex thread.', {
         type: 'object',
         additionalProperties: false,
@@ -278,7 +233,6 @@ export function filterCodexCommunicationTools(tools, outboundPolicy) {
  */
 export const CODEX_DETACHED_THREAD_DYNAMIC_TOOLS = CODEX_APP_DYNAMIC_TOOLS.filter((entry) => (entry.name !== CANON_RUNTIME_CONTROL_TOOL_NAME
     && entry.name !== CODEX_NO_REPLY_TOOL_NAME));
-const CODEX_APP_TOOL_NAMES = new Set(CODEX_APP_DYNAMIC_TOOLS.map((entry) => String(entry.name)));
 const UNSUPPORTED_TOOLS = new Map([
     ['automation_update', 'Canon does not manage Codex Desktop automations.'],
     ['navigate_to_codex_page', 'Canon has no Codex Desktop page to navigate.'],
@@ -288,6 +242,12 @@ const UNSUPPORTED_TOOLS = new Map([
     ['get_handoff_status', 'Canon does not manage Codex Desktop handoffs.'],
     ['set_thread_pinned', 'Pinned thread state is Codex Desktop-only.'],
 ]);
+// Historical calls must still reach their specific rejection, even though
+// unsupported tools are no longer advertised to the model.
+const RECOGNIZED_CODEX_APP_TOOL_NAMES = new Set([
+    ...CODEX_APP_DYNAMIC_TOOLS.map((entry) => entry.name),
+    ...UNSUPPORTED_TOOLS.keys(),
+]);
 export function isCodexAppToolCall(params) {
     const namespace = typeof params.namespace === 'string' ? params.namespace : null;
     const rawTool = typeof params.tool === 'string' ? params.tool.trim() : '';
@@ -296,7 +256,7 @@ export function isCodexAppToolCall(params) {
         return rawTool.startsWith('codex_app.');
     return namespace === 'codex_app'
         || rawTool.startsWith('codex_app.')
-        || (toolName ? CODEX_APP_TOOL_NAMES.has(toolName) : false);
+        || (toolName ? RECOGNIZED_CODEX_APP_TOOL_NAMES.has(toolName) : false);
 }
 export function deniedCodexAppToolResult(reason) {
     return toolResult(false, { error: reason });
@@ -397,7 +357,7 @@ export function classifyCodexAppToolRequest(input) {
 }
 export async function handleCodexAppToolCall(runtime, params) {
     const toolName = normalizeToolName(params.tool);
-    if (!toolName || !CODEX_APP_TOOL_NAMES.has(toolName)) {
+    if (!toolName || !RECOGNIZED_CODEX_APP_TOOL_NAMES.has(toolName)) {
         return toolResult(false, { error: `Unsupported codex_app tool: ${String(params.tool ?? 'unknown')}` });
     }
     if (toolName === CODEX_NO_REPLY_TOOL_NAME) {

package/dist/host.d.ts

@@ -1,10 +1,13 @@
 #!/usr/bin/env node
 import { type TurnArtifactRoutingDecision, type TurnArtifactRoutingMode, type RecoveryCheckpointTracker } from '@canonmsg/coding-agent-host';
-import { type CanonRuntimeCommandDescriptor, type CanonRuntimeDescriptor, type CanonRuntimePresentationPolicy, type ExecutionEnvironmentMode, type PreparedExecutionEnvironment, type WorkspaceOption, type CanonWorkspaceRootMetadata, type RuntimeStreamingPayload, type TurnLifecycleState, type TurnOutputBlock, type TurnVerbosity, type TurnVerbosityConfig } from '@canonmsg/core';
-import { type CodexSandboxMode } from './adapter.js';
-import { type CodexSkillMetadata } from './app-server-adapter.js';
+import { type CanonRuntimeCommandDescriptor, type CanonRuntimeDescriptor, type CanonRuntimeFact, type CanonRuntimePresentationPolicy, type ExecutionEnvironmentMode, type PreparedExecutionEnvironment, type WorkspaceOption, type CanonWorkspaceRootMetadata, type DeliveryIntent, type RuntimeStreamingPayload, type TurnLifecycleState, type TurnOutputBlock, type TurnVerbosity, type TurnVerbosityConfig } from '@canonmsg/core';
+import type { AgentReplyAuthorityV1 } from '@canonmsg/backend-contracts';
+import { CodexConversationAdapter, type CodexSandboxMode } from './adapter.js';
+import { CodexAppServerAdapter, type CodexSkillMetadata } from './app-server-adapter.js';
 import { deriveCodexPermissionEnvelope } from './permission-mode.js';
+import { type CommandBlockTracker } from './turn-activity.js';
 import { type CodexControlOption } from './model-catalog.js';
+type CodexAdapter = CodexConversationAdapter | CodexAppServerAdapter;
 interface HostSessionState {
     lastError?: string;
     model?: string;
@@ -21,6 +24,63 @@ export declare function buildCodexInitialSessionState(input: {
     permissionMode?: string;
     effort?: string | null;
 }): HostSessionState;
+type ArtifactRoutingMode = 'workspace-generated' | 'disabled';
+interface Session {
+    conversationId: string;
+    cwd: string;
+    environment: PreparedExecutionEnvironment;
+    adapter: CodexAdapter;
+    queue: Array<{
+        prompt: string;
+        skillInvocationText?: string;
+        planMode?: boolean;
+        intent: DeliveryIntent;
+        sourceMessageId?: string | null;
+        markAccepted?: boolean;
+        imagePaths?: string[];
+        mediaAddDirs?: string[];
+        artifactRoutingMode?: ArtifactRoutingMode;
+        canUseCodexAppTools?: boolean;
+        /**
+         * Resolved when this message arrived and carried here, so a prompt that
+         * waits in the queue still runs under the answer it arrived with. Absent on
+         * a continuation prompt (a plan-review result), which inherits whatever the
+         * conversation last resolved.
+         */
+        turnVerbosity?: TurnVerbosity;
+        requestingUserId: string | null;
+        replyAuthority: AgentReplyAuthorityV1 | null;
+    }>;
+    running: boolean;
+    state: HostSessionState;
+    policyFingerprint: string;
+    turnState: TurnLifecycleState;
+    currentTurnId: string | null;
+    currentTurnOpenedAt: number | null;
+    currentTurnUpdatedAt: number | null;
+    currentTurnCanUseCodexAppTools: boolean;
+    currentReplyAuthority: AgentReplyAuthorityV1 | null;
+    /** Cancels Canon interactions created by the currently running Codex turn. */
+    currentTurnAbortController: AbortController | null;
+    /**
+     * The verbosity the RUNNING turn was opened with. Promoted off the queue
+     * entry at `runNextTurn` and never re-read mid-turn, so the live writer, the
+     * turn-state writer and the final's trail cannot disagree with each other.
+     */
+    turnVerbosity: TurnVerbosity;
+    /** The running turn called `no_reply`: end it without posting anything. */
+    currentTurnSilenced: boolean;
+    activeSelfContextId: string | null;
+    lastAcceptedIntent: DeliveryIntent | null;
+    resetRequested: boolean;
+    lastActivity: number;
+    typingKeepaliveTimer: ReturnType<typeof setInterval> | null;
+    closed: boolean;
+    turnLiveText: string;
+    turnBlocks: TurnOutputBlock[];
+    turnCommandBlocks: CommandBlockTracker;
+}
+export declare function buildCodexSessionFacts(session?: Pick<Session, 'closed' | 'adapter'>): CanonRuntimeFact[];
 export declare function createCodexRecoveryCheckpointTracker(persist: (messageId: string) => boolean): RecoveryCheckpointTracker;
 /** Conservative fallback used only when native app-server discovery is unavailable. */
 export declare const CODEX_EFFORT_OPTIONS: readonly CodexControlOption[];

package/dist/host.js

@@ -69,6 +69,23 @@ export function buildCodexInitialSessionState(input) {
         state: 'idle',
     };
 }
+export function buildCodexSessionFacts(session) {
+    if (!session || session.closed)
+        return [];
+    const adapter = session.adapter;
+    const appServer = adapter instanceof CodexAppServerAdapter;
+    const facts = [{
+            id: 'runtime', label: 'Runtime', value: appServer ? 'Codex app-server' : 'Codex CLI', group: 'runtime',
+        }];
+    if (appServer) {
+        const observed = adapter.getObservedSettings();
+        if (observed.model)
+            facts.push({ id: 'model', label: 'Model', value: observed.model, group: 'model' });
+        if (observed.effort)
+            facts.push({ id: 'reasoning', label: 'Reasoning', value: observed.effort, group: 'model' });
+    }
+    return facts;
+}
 const MAX_SESSIONS = 12;
 export function createCodexRecoveryCheckpointTracker(persist) {
     return createRecoveryCheckpointTracker(persist);
@@ -133,10 +150,10 @@ export function buildCodexRuntimeDescriptor(input) {
     const commands = [
         {
             id: 'runtime-status',
-            label: 'Runtime status',
-            description: 'Open Codex runtime details.',
+            label: 'Session info',
+            description: 'Open Canon session information.',
             primitive: 'runtime.status',
-            aliases: ['status'],
+            aliases: ['session-info'],
             category: 'details',
             placements: ['composer_slash', 'command_palette'],
             availability: ['always'],
@@ -272,14 +289,6 @@ export function resolveWorkspaceCwd() {
         defaultCwd: workingDir,
     });
 }
-function resolveExecutionFallbackReason(environment) {
-    if (!environment?.reason || environment.mode !== 'locked') {
-        return null;
-    }
-    return environment.reason === 'Sharing the base workspace (locked mode)'
-        ? null
-        : environment.reason;
-}
 function stringArg(args, key) {
     const value = args[key];
     return typeof value === 'string' && value.trim() ? value.trim() : undefined;
@@ -810,9 +819,6 @@ export async function main() {
         client,
         conversationCache,
     });
-    function resolveWorkspaceIdForBaseCwd(baseCwd) {
-        return workspaceOptions.find((option) => option.cwd === baseCwd)?.id;
-    }
     async function refreshKnownConversationIds(force = false) {
         if (!force && Date.now() - lastKnownConversationRefreshAt < HEARTBEAT_MS) {
             return;
@@ -1349,6 +1355,7 @@ export async function main() {
     function enqueuePrompt(session, prompt, intent = 'queue', toFront = false, sourceMessageId, markAccepted = false, imagePaths = [], mediaAddDirs = [], planMode = false, turn = {}) {
         const nextPrompt = {
             prompt,
+            skillInvocationText: turn.skillInvocationText,
             intent,
             sourceMessageId,
             markAccepted,
@@ -1895,6 +1902,7 @@ export async function main() {
         if (session.running && deliveryIntent === 'interrupt') {
             enqueuePrompt(session, prompt, deliveryIntent, true, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode, {
                 ...resolveCodexTurnModes(participantContext, input.message),
+                skillInvocationText: input.message.senderType === 'human' ? input.message.text ?? undefined : undefined,
                 replyAuthority: input.replyAuthority ?? null,
             });
             console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Interrupting current turn for explicit human send-now`);
@@ -1906,6 +1914,7 @@ export async function main() {
         }
         enqueuePrompt(session, prompt, deliveryIntent, false, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode, {
             ...resolveCodexTurnModes(participantContext, input.message),
+            skillInvocationText: input.message.senderType === 'human' ? input.message.text ?? undefined : undefined,
             replyAuthority: input.replyAuthority ?? null,
         });
     }
@@ -2137,6 +2146,7 @@ export async function main() {
             };
             const runTurnOnce = () => session.adapter.runTurn(turnPrompt, handleCodexEvent, logCodexLine, turnImagePaths, turnMediaAddDirs, {
                 planMode: nextTurn.planMode,
+                skillInvocationText: nextTurn.skillInvocationText,
                 onServerRequest: (request) => handleCodexServerRequest(session, request, nextTurn.requestingUserId ?? null, nextTurn.sourceMessageId ?? null),
             });
             let result = await runTurnOnce();
@@ -2590,71 +2600,15 @@ export async function main() {
         if (signal.aborted)
             return;
         const results = await Promise.allSettled(Array.from(knownConversationIds).map(async (conversationId) => {
-            const session = sessions.get(conversationId);
-            const workspaceId = session
-                ? resolveWorkspaceIdForBaseCwd(session.environment.baseCwd)
-                : runtimeDescriptor.defaultWorkspaceId;
-            const workspace = workspaceOptions.find((option) => option.id === workspaceId) ?? null;
             const descriptor = runtimeDescriptor.runtimeDescriptor;
             if (!descriptor)
                 return;
-            const payload = {
-                descriptor,
+            await runtimeState.writeRuntimeInfo(conversationId, {
                 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',
-                    },
-                    {
-                        id: 'streaming',
-                        label: 'Live output',
-                        value: useAppServer
-                            ? 'Plans, questions, approvals, tools, and message deltas'
-                            : 'Thinking, tools, and completed-message previews',
-                    },
-                    {
-                        id: 'codex-cli',
-                        label: 'Codex CLI',
-                        value: codexCliStatus.version ?? (codexCliStatus.raw ?? 'Version unknown'),
-                        tone: codexCliStatus.version ? 'default' : 'warning',
-                    },
-                    {
-                        id: 'nativeActions',
-                        label: 'Native actions',
-                        value: useAppServer ? 'Enabled' : 'Limited until app-server transport',
-                        ...(useAppServer ? {} : { tone: 'warning' }),
-                    },
-                    {
-                        id: 'mediaOut',
-                        label: 'Media out',
-                        value: 'Generated media artifacts',
-                    },
-                ],
-                execution: {
-                    resolvedWorkspaceLabel: workspace?.label ?? workspaceId ?? null,
-                    resolvedCwd: session?.cwd ?? workspace?.cwd ?? workingDir,
-                    workspaceRootId: workspace?.workspaceRootId ?? null,
-                    workspaceRelativePath: workspace?.workspaceRelativePath ?? null,
-                    executionMode: session?.environment.mode ?? null,
-                    executionBranch: session?.environment.branch ?? null,
-                    worktreePath: session?.environment.worktreePath ?? null,
-                    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.',
-                ],
-            };
-            await runtimeState.writeRuntimeInfo(conversationId, payload);
+                // The shared publisher sanitizes configuration while retaining commands.
+                descriptor,
+                facts: buildCodexSessionFacts(sessions.get(conversationId)),
+            });
         }));
         const failure = results.find((result) => result.status === 'rejected');
         if (failure?.status === 'rejected')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.29.2",
+  "version": "0.29.4",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/index.js",
@@ -29,10 +29,10 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@canonmsg/agent-sdk": "^10.2.0",
+    "@canonmsg/agent-sdk": "^10.2.1",
     "@canonmsg/agent-tools": "^0.9.0",
     "@canonmsg/coding-agent-host": "^0.7.0",
-    "@canonmsg/core": "^12.2.0",
+    "@canonmsg/core": "^12.3.1",
     "@canonmsg/rich-cards": "^0.10.4"
   },
   "engines": {