@canonmsg/codex-plugin 0.6.6 → 0.9.0

package/README.md

@@ -37,7 +37,15 @@ You do not need a git repo for host mode. The plugin passes `--skip-git-repo-che
 
 ## Current limitation
 
-The stable `codex exec --json` surface exposes completed assistant messages and tool activity, but not token-by-token text deltas. v1 therefore reports live status and publishes the final reply when the turn completes, instead of true token streaming.
+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.
+
+Current Canon control truth for Codex host mode:
+
+- model is live-visible, but current changes apply on the next turn rather than mid-turn
+- workspace selection is setup-only
+- execution mode selection is setup-only
+- the current `Execution policy`/permission choice is setup-only
+- advanced Codex-only controls such as effort, sandbox policy, approval reviewer, or apps/plugins inventory are not exposed on the current transport unless the runtime can actually report them
 
 ## Working directory
 
@@ -45,12 +53,24 @@ The stable `codex exec --json` surface exposes completed assistant messages and
 canon-codex --cwd /path/to/project
 ```
 
+Advertise multiple project choices to the Canon app:
+
+```bash
+canon-codex --cwd ~/dev --workspace-root ~/dev
+```
+
+`--cwd` is the default workspace. Each `--workspace-root` value is an approved local root; the host discovers immediate child projects with common markers such as `.git`, `package.json`, `pyproject.toml`, `Cargo.toml`, or `go.mod` and publishes them as selectable projects during session creation. Use repeated `--workspace /path/to/project` entries to advertise specific projects outside those roots. Worktree mode creates a per-conversation git worktree under `~/.canon/conversation-worktrees`; shared-project mode runs directly in the selected directory.
+
+If worktree isolation is requested for a project that cannot support it, Canon may fall back to shared-project execution and surface the fallback reason in session details instead of failing the session outright.
+
 Useful flags:
 
 ```bash
 canon-codex --cwd /path/to/project --model gpt-5.4 --full-auto
 ```
 
+Codex also supports `--add-dir /extra/path` for additional writable directories passed through to `codex exec`. Canon does not yet render those extra directories as workspace choices.
+
 Recent Codex CLI releases no longer accept `--ask-for-approval` with `codex exec`. If you previously launched Canon with `--sandbox workspace-write --ask-for-approval never`, switch to `--full-auto`.
 
 Local smoke test:

package/dist/host-runtime.d.ts

@@ -97,17 +97,23 @@ export declare function publishHostSessionSnapshots(input: {
     liveSessionConfigByConversation?: ReadonlyMap<string, {
         model?: string;
         permissionMode?: string;
+        effort?: string;
+        runtimeControlValues?: Record<string, string>;
         workspaceId?: string;
         executionMode?: SessionWorkspaceConfig['executionMode'];
         executionBranch?: string | null;
     }>;
 }): Promise<void>;
-export declare function readHostSessionConfig<TExtra extends string = never>(raw: unknown, extraStringFields?: readonly TExtra[]): (SessionWorkspaceConfig & Partial<Record<TExtra, string>>) | null;
+export declare function readHostSessionConfig<TExtra extends string = never>(raw: unknown, extraStringFields?: readonly TExtra[]): (SessionWorkspaceConfig & Partial<Record<TExtra, string>> & {
+    runtimeControlValues?: Record<string, string>;
+}) | null;
 export declare function loadHostSessionConfig<TExtra extends string = never>(input: {
     conversationId: string;
     agentId: string;
     extraStringFields?: readonly TExtra[];
-}): Promise<(SessionWorkspaceConfig & Partial<Record<TExtra, string>>) | null>;
+}): Promise<(SessionWorkspaceConfig & Partial<Record<TExtra, string>> & {
+    runtimeControlValues?: Record<string, string>;
+}) | null>;
 export declare function resolveHostWorkspaceCwd(input: {
     workspaceOptions: HostWorkspaceResolverOption[];
     config: {

package/dist/host-runtime.js

@@ -162,6 +162,10 @@ export async function publishHostSessionSnapshots(input) {
             sessionConfig: {
                 ...(mergedConfig.model ? { model: mergedConfig.model } : {}),
                 ...(mergedConfig.permissionMode ? { permissionMode: mergedConfig.permissionMode } : {}),
+                ...(mergedConfig.effort ? { effort: mergedConfig.effort } : {}),
+                ...(mergedConfig.runtimeControlValues
+                    ? { runtimeControlValues: mergedConfig.runtimeControlValues }
+                    : {}),
                 ...(mergedConfig.workspaceId ? { workspaceId: mergedConfig.workspaceId } : {}),
                 ...(mergedConfig.executionMode ? { executionMode: mergedConfig.executionMode } : {}),
             },
@@ -183,6 +187,8 @@ export async function publishHostSessionSnapshots(input) {
             hostMode: true,
             model: snapshot.model ?? null,
             permissionMode: snapshot.permissionMode ?? null,
+            effort: snapshot.effort ?? null,
+            runtimeControlValues: snapshot.runtimeControlValues ?? null,
             workspaceId: snapshot.workspaceId ?? null,
             executionMode: snapshot.executionMode ?? null,
             executionBranch,
@@ -204,9 +210,16 @@ export function readHostSessionConfig(raw, extraStringFields = []) {
         const value = normalizeOptionalString(data[field]);
         return value ? [[field, value]] : [];
     }));
+    const runtimeControlValues = Object.fromEntries(Object.entries(data.runtimeControlValues && typeof data.runtimeControlValues === 'object'
+        ? data.runtimeControlValues
+        : {}).flatMap(([key, value]) => {
+        const normalizedValue = normalizeOptionalString(value);
+        return normalizedValue ? [[key, normalizedValue]] : [];
+    }));
     return {
         ...(baseConfig ?? {}),
         ...extraConfig,
+        ...(Object.keys(runtimeControlValues).length > 0 ? { runtimeControlValues } : {}),
     };
 }
 export async function loadHostSessionConfig(input) {

package/dist/host.js

@@ -3,7 +3,7 @@ import { setDefaultResultOrder } from 'node:dns';
 import { randomUUID } from 'node:crypto';
 import { parseArgs } from 'node:util';
 import { getCodexImagePath, materializeMessageMedia, } from '@canonmsg/agent-sdk';
-import { buildConfiguredWorkspaceOptions, buildPublicWorkspaceOptions, EXECUTION_ENVIRONMENT_MODES, ExecutionEnvironmentError, CanonClient, CanonStream, clearSessionState, clearTurnState, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, FINAL_MESSAGE_HANDOFF_MS, getActiveProfile, initRTDBAuth, normalizeTurnMetadata, normalizeTurnState, prepareConversationEnvironment, releaseLock, releaseConversationEnvironment, resolveCanonAgent, rtdbRead, rtdbWrite, shouldTriggerAgentTurn, writeSessionState, writeTurnState, } from '@canonmsg/core';
+import { buildConfiguredWorkspaceOptionsWithRoots, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, EXECUTION_ENVIRONMENT_MODES, ExecutionEnvironmentError, CanonClient, CanonStream, clearSessionState, clearTurnState, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, FINAL_MESSAGE_HANDOFF_MS, getActiveProfile, initRTDBAuth, normalizeTurnMetadata, normalizeTurnState, prepareConversationEnvironment, releaseLock, releaseConversationEnvironment, resolveCanonAgent, rtdbRead, rtdbWrite, writeRuntimeInfo, shouldTriggerAgentTurn, writeSessionState, writeTurnState, } from '@canonmsg/core';
 import { buildCanonHostPrompt, buildHydratedInboundContext, createConversationMetadataLoader, loadHostSessionConfig, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, resolveHostWorkspaceCwd, } from './host-runtime.js';
 import { buildInboundContextLines, decideAutoReply, } from './inbound-policy.js';
 import { CodexConversationAdapter, } from './adapter.js';
@@ -23,6 +23,93 @@ const CODEX_RUNTIME_CAPABILITIES = {
 };
 let workingDir = process.cwd();
 let workspaceOptions = [];
+let workspaceRoots = [];
+let workspaceRootMetadata = [];
+function buildCodexRuntimeDescriptor(input) {
+    return {
+        coreControls: [
+            {
+                id: 'model',
+                label: 'Model',
+                options: input.models,
+                defaultValue: input.models[0]?.value ?? null,
+                availability: 'setup_and_live',
+                liveBehavior: 'next_turn',
+                selectionPolicy: 'inherit',
+            },
+            {
+                id: 'workspace',
+                label: 'Project',
+                options: input.workspaces.map((workspace) => ({
+                    value: workspace.id,
+                    label: workspace.label,
+                    ...(workspace.description ? { description: workspace.description } : {}),
+                    ...(workspace.workspaceRootId ? { workspaceRootId: workspace.workspaceRootId } : {}),
+                    ...(workspace.workspaceRelativePath ? { workspaceRelativePath: workspace.workspaceRelativePath } : {}),
+                    ...(workspace.source ? { source: workspace.source } : {}),
+                })),
+                defaultValue: input.workspaces[0]?.id ?? null,
+                availability: 'setup',
+                liveBehavior: 'none',
+                selectionPolicy: 'inherit',
+                description: input.workspaceRoots?.length
+                    ? 'Choose one of the projects discovered inside the approved local roots for this host.'
+                    : 'Choose one of the local projects advertised by this host.',
+            },
+            {
+                id: 'executionMode',
+                label: 'Execution mode',
+                options: input.executionModes.map((mode) => ({
+                    value: mode,
+                    label: mode === 'worktree' ? 'Isolated worktree' : 'Use shared project',
+                    description: mode === 'worktree'
+                        ? 'Creates or reuses a per-conversation git worktree under ~/.canon/conversation-worktrees when the selected project is a git repo.'
+                        : 'Runs directly in the selected project folder. Changes happen there.',
+                })),
+                defaultValue: null,
+                availability: 'setup',
+                liveBehavior: 'none',
+                selectionPolicy: 'required_explicit',
+            },
+        ],
+        runtimeControls: [
+            {
+                id: 'permissionMode',
+                label: 'Execution policy',
+                options: input.permissionModes,
+                defaultValue: input.defaultPermissionMode ?? null,
+                availability: 'setup',
+                liveBehavior: 'none',
+                selectionPolicy: 'inherit',
+            },
+        ],
+        actions: [
+            {
+                id: 'stop',
+                label: 'Stop',
+                description: 'Interrupt the current Codex exec turn.',
+                aliases: ['stop'],
+                category: 'turn',
+                placements: ['composer_slash', 'command_palette'],
+                availability: ['busy'],
+                dispatch: { kind: 'signal', signal: 'interrupt' },
+            },
+            {
+                id: 'stop-and-clear-queue',
+                label: 'Stop & clear queue',
+                description: 'Interrupt the current Codex exec turn and drop queued Canon messages.',
+                aliases: ['stop-clear', 'clear-queue'],
+                category: 'turn',
+                placements: ['composer_slash', 'command_palette', 'session_strip'],
+                availability: ['busy_with_queue'],
+                dispatch: { kind: 'signal', signal: 'stop_and_drop' },
+            },
+        ],
+        workspaceRoots: input.workspaceRoots,
+        supportsInterrupt: true,
+        streamingTextMode: 'snapshot',
+    };
+}
 function normalizeRuntimeTurnState(value) {
     const normalizedTurn = normalizeTurnState(value);
     if (normalizedTurn) {
@@ -49,11 +136,10 @@ async function loadSessionConfig(conversationId, agentId) {
         extraStringFields: ['permissionMode'],
     });
 }
-// Default to 'locked' (shared workspace) when no mode has been picked. The
-// UI still lets owners flip to 'worktree'; this just stops sessions from
-// failing closed when the mode has never been written.
 function resolveSessionExecutionMode(config) {
-    return config?.executionMode ?? 'locked';
+    if (config?.executionMode)
+        return config.executionMode;
+    throw new ExecutionEnvironmentError('Session config is missing an execution mode.', 'Choose Isolated worktree or Use shared project before starting this coding session.');
 }
 function resolveWorkspaceCwd(config) {
     return resolveHostWorkspaceCwd({
@@ -62,6 +148,14 @@ function resolveWorkspaceCwd(config) {
         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 buildCanonPrompt(input) {
     return buildCanonHostPrompt({
         hostLabel: 'Codex',
@@ -101,6 +195,7 @@ export async function main() {
             'codex-profile': { type: 'string' },
             'add-dir': { type: 'string', multiple: true },
             workspace: { type: 'string', multiple: true },
+            'workspace-root': { type: 'string', multiple: true },
             config: { type: 'string', multiple: true },
             'codex-bin': { type: 'string' },
             'full-auto': { type: 'boolean' },
@@ -109,7 +204,17 @@ export async function main() {
         strict: true,
     });
     workingDir = (typeof args.cwd === 'string' ? args.cwd : null) || process.cwd();
-    workspaceOptions = buildConfiguredWorkspaceOptions(workingDir, args.workspace ?? []);
+    const workspaceDiscovery = buildConfiguredWorkspaceOptionsWithRoots({
+        primaryCwd: workingDir,
+        configuredWorkspaces: args.workspace ?? [],
+        workspaceRoots: args['workspace-root'] ?? [],
+    });
+    workspaceOptions = workspaceDiscovery.workspaceOptions;
+    workspaceRoots = workspaceDiscovery.workspaceRoots;
+    workspaceRootMetadata = buildPublicWorkspaceRoots(workspaceRoots);
+    for (const warning of workspaceDiscovery.warnings) {
+        console.error(`[canon-codex] ${warning}`);
+    }
     if (typeof args['ask-for-approval'] === 'string') {
         console.error('[canon-codex] Note: newer Codex CLI releases do not accept --ask-for-approval for `codex exec`; Canon will translate compatible legacy usage when possible.');
     }
@@ -194,6 +299,10 @@ export async function main() {
             cwd: session.cwd,
             executionMode: session.environment.mode,
             ...(session.environment.branch ? { executionBranch: session.environment.branch } : {}),
+            ...(session.environment.worktreePath ? { worktreePath: session.environment.worktreePath } : {}),
+            ...(resolveExecutionFallbackReason(session.environment)
+                ? { executionFallbackReason: resolveExecutionFallbackReason(session.environment) ?? undefined }
+                : {}),
             hostMode: true,
             clientType: 'codex',
             state: session.state.state,
@@ -227,11 +336,33 @@ export async function main() {
         clearStreaming(conversationId);
         client.setTyping(conversationId, false).catch(() => { });
     }
+    function refreshVisibleWorkSignal(session) {
+        if (!session.running || session.closed)
+            return;
+        if (session.turnState !== 'thinking' && session.turnState !== 'tool')
+            return;
+        client.setTyping(session.conversationId, true, 'thinking').catch(() => { });
+    }
+    function startVisibleWorkSignal(session) {
+        refreshVisibleWorkSignal(session);
+        if (session.typingKeepaliveTimer)
+            return;
+        session.typingKeepaliveTimer = setInterval(() => {
+            refreshVisibleWorkSignal(session);
+        }, 3500);
+    }
+    function stopVisibleWorkSignal(session) {
+        if (session.typingKeepaliveTimer) {
+            clearInterval(session.typingKeepaliveTimer);
+            session.typingKeepaliveTimer = null;
+        }
+    }
     function closeSession(conversationId) {
         const session = sessions.get(conversationId);
         if (!session)
             return;
         session.closed = true;
+        stopVisibleWorkSignal(session);
         releaseConversationEnvironment(session.environment);
         clearStreaming(conversationId);
         clearSessionState(conversationId, agentId).catch(() => { });
@@ -319,6 +450,7 @@ export async function main() {
                     currentTurnOpenedAt: null,
                     lastAcceptedIntent: null,
                     lastActivity: Date.now(),
+                    typingKeepaliveTimer: null,
                     closed: false,
                 };
                 sessions.set(conversationId, session);
@@ -398,7 +530,12 @@ export async function main() {
             const message = error instanceof Error ? error.message : String(error);
             const userMessage = error instanceof ExecutionEnvironmentError ? error.userMessage : message;
             console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Failed to create session: ${message}`);
-            await client.sendMessage(input.conversationId, `I couldn't start a coding session for this workspace: ${userMessage}`).catch(() => { });
+            await client.sendMessage(input.conversationId, `I couldn't start a coding session for this workspace: ${userMessage}`, {
+                metadata: {
+                    turnSemantics: 'turn_complete',
+                    turnComplete: true,
+                },
+            }).catch(() => { });
             return;
         }
         const turnMetadata = normalizeTurnMetadata(input.message.metadata);
@@ -439,7 +576,7 @@ export async function main() {
         await markQueuedMessageAccepted(session.conversationId, nextTurn.sourceMessageId, nextTurn.markAccepted);
         writeState(session);
         writeTurn(session);
-        client.setTyping(session.conversationId, true, 'thinking').catch(() => { });
+        startVisibleWorkSignal(session);
         rtdbWrite(`/streaming/${session.conversationId}/${agentId}`, {
             text: 'Thinking…',
             status: 'thinking',
@@ -457,6 +594,8 @@ export async function main() {
                 if (event.type === 'message') {
                     session.turnState = 'streaming';
                     writeTurn(session);
+                    stopVisibleWorkSignal(session);
+                    client.setTyping(session.conversationId, false).catch(() => { });
                     rtdbWrite(`/streaming/${session.conversationId}/${agentId}`, {
                         text: event.text,
                         status: 'streaming',
@@ -467,7 +606,7 @@ export async function main() {
                 if (event.type === 'command.started') {
                     session.turnState = 'tool';
                     writeTurn(session);
-                    client.setTyping(session.conversationId, false).catch(() => { });
+                    startVisibleWorkSignal(session);
                     rtdbWrite(`/streaming/${session.conversationId}/${agentId}`, {
                         text: summarizeCommand(event.command),
                         status: 'tool',
@@ -519,6 +658,7 @@ export async function main() {
             else if (result.interrupted) {
                 session.turnState = 'interrupted';
                 writeTurn(session);
+                stopVisibleWorkSignal(session);
                 clearStreaming(session.conversationId);
                 client.setTyping(session.conversationId, false).catch(() => { });
                 console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn interrupted`);
@@ -541,6 +681,7 @@ export async function main() {
             console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn failed:`, error);
         }
         finally {
+            stopVisibleWorkSignal(session);
             session.running = false;
             session.state.state = 'idle';
             session.turnState = 'idle';
@@ -570,6 +711,14 @@ export async function main() {
         ...(codexPermissionEnvelope.defaultPermissionMode
             ? { defaultPermissionMode: codexPermissionEnvelope.defaultPermissionMode }
             : {}),
+        runtimeDescriptor: buildCodexRuntimeDescriptor({
+            models: [],
+            workspaces: buildPublicWorkspaceOptions(workspaceOptions),
+            workspaceRoots: workspaceRootMetadata,
+            executionModes: hostAvailableExecutionModes,
+            permissionModes: [...codexPermissionEnvelope.availablePermissionModes],
+            defaultPermissionMode: codexPermissionEnvelope.defaultPermissionMode,
+        }),
     };
     const publishRuntimeHeartbeat = async () => {
         if (!streamConnected)
@@ -602,6 +751,59 @@ export async function main() {
         }).catch((error) => {
             console.error('[canon-codex] Failed to publish session snapshots:', error);
         });
+        await Promise.all(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 payload = {
+                descriptor: runtimeDescriptor.runtimeDescriptor ?? buildCodexRuntimeDescriptor({
+                    models: runtimeDescriptor.availableModels ?? [],
+                    workspaces: buildPublicWorkspaceOptions(workspaceOptions),
+                    workspaceRoots: workspaceRootMetadata,
+                    executionModes: hostAvailableExecutionModes,
+                    permissionModes: [...codexPermissionEnvelope.availablePermissionModes],
+                    defaultPermissionMode: codexPermissionEnvelope.defaultPermissionMode,
+                }),
+                surfaceMode: 'host',
+                statusItems: [
+                    {
+                        id: 'transport',
+                        label: 'Transport',
+                        value: 'exec --json',
+                    },
+                    {
+                        id: 'streaming',
+                        label: 'Live output',
+                        value: 'Thinking, tools, and completed-message previews',
+                    },
+                    {
+                        id: 'nativeActions',
+                        label: 'Native actions',
+                        value: 'Limited until app-server transport',
+                        tone: 'warning',
+                    },
+                ],
+                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: [
+                    '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.',
+                ],
+            };
+            await writeRuntimeInfo(conversationId, agentId, payload);
+        })).catch((error) => {
+            console.error('[canon-codex] Failed to publish runtime info:', error);
+        });
     };
     const stream = new CanonStream({
         apiKey,
@@ -643,6 +845,14 @@ export async function main() {
             ...(codexPermissionEnvelope.defaultPermissionMode
                 ? { defaultPermissionMode: codexPermissionEnvelope.defaultPermissionMode }
                 : {}),
+            runtimeDescriptor: buildCodexRuntimeDescriptor({
+                models: [],
+                workspaces: buildPublicWorkspaceOptions(workspaceOptions),
+                workspaceRoots: workspaceRootMetadata,
+                executionModes: hostAvailableExecutionModes,
+                permissionModes: [...codexPermissionEnvelope.availablePermissionModes],
+                defaultPermissionMode: codexPermissionEnvelope.defaultPermissionMode,
+            }),
         };
     }
     catch {
@@ -654,6 +864,14 @@ export async function main() {
             ...(codexPermissionEnvelope.defaultPermissionMode
                 ? { defaultPermissionMode: codexPermissionEnvelope.defaultPermissionMode }
                 : {}),
+            runtimeDescriptor: buildCodexRuntimeDescriptor({
+                models: [],
+                workspaces: buildPublicWorkspaceOptions(workspaceOptions),
+                workspaceRoots: workspaceRootMetadata,
+                executionModes: hostAvailableExecutionModes,
+                permissionModes: [...codexPermissionEnvelope.availablePermissionModes],
+                defaultPermissionMode: codexPermissionEnvelope.defaultPermissionMode,
+            }),
         };
     }
     try {

package/dist/setup.js

@@ -21,8 +21,10 @@ export function main() {
     console.log('');
     console.log('  2. Start the host in a project directory and keep it running');
     console.log('     canon-codex --cwd /path/to/project');
+    console.log('     canon-codex --cwd ~/dev --workspace-root ~/dev');
     console.log('');
     console.log('     A git repo is not required; any readable directory works.');
+    console.log('     Use --workspace-root to let Canon offer discovered projects inside an approved root.');
     console.log('');
     console.log('Optional flags:');
     console.log('  --model gpt-5.4');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.6.6",
+  "version": "0.9.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": "^0.8.3",
-    "@canonmsg/core": "^0.7.5"
+    "@canonmsg/agent-sdk": "^0.9.2",
+    "@canonmsg/core": "^0.10.0"
   },
   "engines": {
     "node": ">=18.0.0"