@canonmsg/codex-plugin 0.3.0 → 0.5.0

package/README.md

@@ -22,6 +22,8 @@ canon-codex --cwd /path/to/project
 
 Registration saves a Canon profile in `~/.canon/agents.json`, the same shared profile store used by the Claude Code integration and supported by the OpenClaw plugin.
 
+If the terminal closes or the machine restarts, the agent goes offline until you start the host again. To bring back the same registered agent, rerun `canon-codex --cwd /path/to/project`. Do not run registration again unless Canon tells you the saved API key is invalid. If you registered multiple profiles, relaunch the same one with `CANON_AGENT=<profile> canon-codex --cwd /path/to/project`.
+
 You do not need a git repo for host mode. The plugin passes `--skip-git-repo-check` to Codex, so any readable working directory is valid.
 
 ## What v1 supports
@@ -71,6 +73,12 @@ If you installed the package only inside this repo and not globally, run the bui
 node packages/codex-plugin/dist/host.js --cwd /path/to/project --full-auto
 ```
 
+If `canon-codex` starts but cannot find the `codex` binary, either fix your `PATH` or launch with an explicit binary path:
+
+```bash
+canon-codex --cwd /path/to/project --codex-bin /absolute/path/to/codex
+```
+
 If Canon rejects authenticated requests with `401 Invalid API key`, the stored Canon profile needs a fresh key. Rerun registration for the same profile to overwrite `~/.canon/agents.json`, then restart the host:
 
 ```bash

package/dist/adapter.d.ts

@@ -36,7 +36,7 @@ export declare class CodexConversationAdapter {
     private readonly codexBin;
     private model;
     private readonly sandbox;
-    private readonly approvalPolicy;
+    private readonly legacyApprovalPolicy;
     private readonly codexProfile;
     private readonly addDirs;
     private readonly configOverrides;

package/dist/adapter.js

@@ -5,7 +5,7 @@ export class CodexConversationAdapter {
     codexBin;
     model;
     sandbox;
-    approvalPolicy;
+    legacyApprovalPolicy;
     codexProfile;
     addDirs;
     configOverrides;
@@ -21,7 +21,7 @@ export class CodexConversationAdapter {
         this.codexBin = opts.codexBin ?? 'codex';
         this.model = opts.model ?? null;
         this.sandbox = opts.sandbox ?? null;
-        this.approvalPolicy = opts.approvalPolicy ?? null;
+        this.legacyApprovalPolicy = opts.approvalPolicy ?? null;
         this.codexProfile = opts.codexProfile ?? null;
         this.addDirs = opts.addDirs ?? [];
         this.configOverrides = opts.configOverrides ?? [];
@@ -165,7 +165,7 @@ export class CodexConversationAdapter {
         const args = ['exec', '--json', '--color', 'never', '-C', this.cwd, '--skip-git-repo-check'];
         const execMode = resolveExecMode({
             sandbox: this.sandbox,
-            approvalPolicy: this.approvalPolicy,
+            approvalPolicy: this.legacyApprovalPolicy,
             fullAuto: this.fullAuto,
             bypassApprovalsAndSandbox: this.bypassApprovalsAndSandbox,
         });
@@ -231,15 +231,18 @@ function resolveExecMode(input) {
     if (input.fullAuto) {
         return { fullAuto: true, bypassApprovalsAndSandbox: false };
     }
-    // Newer Codex CLI releases no longer accept --ask-for-approval for `exec`.
-    // Preserve the old Canon example (`--sandbox workspace-write --ask-for-approval never`)
-    // by translating it to the supported `--full-auto` mode.
-    if (input.approvalPolicy === 'never' &&
-        (input.sandbox === 'workspace-write' || input.sandbox == null)) {
+    if (shouldTranslateLegacyApprovalMode(input)) {
         return { fullAuto: true, bypassApprovalsAndSandbox: false };
     }
     return { fullAuto: false, bypassApprovalsAndSandbox: false };
 }
+function shouldTranslateLegacyApprovalMode(input) {
+    // Newer Codex CLI releases no longer accept --ask-for-approval for `exec`.
+    // Keep the compatibility shim isolated here so the rest of the adapter only
+    // deals with the supported execution switches.
+    return input.approvalPolicy === 'never'
+        && (input.sandbox === 'workspace-write' || input.sandbox == null);
+}
 function isIgnorableCodexLog(line) {
     return [
         'Reading additional input from stdin...',

package/dist/host-runtime.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Host-runtime helpers, inlined from @canonmsg/core.
+ *
+ * These helpers glue Canon host wrappers (Codex, Claude Code) to the Canon
+ * RTDB session/runtime surface. They used to live in
+ * `@canonmsg/core/src/host-runtime/` but were moved into each plugin in
+ * media-parity PR C so core does not have to carry host-specific concerns.
+ *
+ * Keep this file in lockstep with the equivalent file in
+ * `packages/claude-code-plugin/src/host-runtime.ts`. If you change the
+ * behavior here, update that copy too and adjust the shared golden
+ * fixture test (`packages/codex-plugin/src/host-runtime.test.ts`).
+ */
+import { type AgentClientType, type AgentRuntime, type CanonClient, type CanonConversation, type CanonMessage, type CanonMessagesPage, type MessageCreatedPayload, type ResolvedAgentBehaviorPolicy, type SessionWorkspaceConfig } from '@canonmsg/core';
+export interface HostInboundParticipantContext {
+    conversationType: CanonConversation['type'] | 'unknown';
+    memberCount: number | null;
+    senderType: 'human' | 'ai_agent';
+    senderName: string;
+    isOwner: boolean;
+    mentionedAgent: boolean;
+    recentSenderTypes: Array<'human' | 'ai_agent'>;
+    recentHumanCount: number;
+    recentAgentCount: number;
+    consecutiveAgentTurns: number;
+    currentAgentStreakStartedByHuman: boolean;
+}
+type HostInboundMessage = {
+    text?: string | null;
+    contentType?: CanonMessage['contentType'] | null;
+    audioUrl?: string | null;
+    audioDurationMs?: number | null;
+    imageUrl?: string | null;
+    attachments?: CanonMessage['attachments'];
+    senderType?: CanonMessage['senderType'];
+    mentions?: string[] | null;
+};
+interface HostWorkspaceResolverOption {
+    id: string;
+    cwd: string;
+}
+export declare function buildCanonHostPrompt(input: {
+    hostLabel: string;
+    content: string;
+    conversationId: string;
+    participantContext: HostInboundParticipantContext;
+    behavior?: ResolvedAgentBehaviorPolicy | null;
+    workSession?: MessageCreatedPayload['message']['workSession'];
+    workSessions?: MessageCreatedPayload['workSessions'];
+    buildInboundContextLines: (context: HostInboundParticipantContext) => string[];
+}): string;
+export declare function renderCanonHostInboundContent(message: HostInboundMessage): string;
+export declare function buildHydratedInboundContext(input: {
+    agentId: string;
+    conversation: CanonConversation | null;
+    page?: CanonMessagesPage | null;
+    message: HostInboundMessage;
+    senderName: string;
+    isOwner: boolean;
+}): {
+    participantContext: HostInboundParticipantContext;
+    behavior?: ResolvedAgentBehaviorPolicy | null;
+    workSessions: NonNullable<MessageCreatedPayload['workSessions']>;
+    hydratedFromPage: boolean;
+};
+export declare function publishHostAgentRuntime(agentId: string, clientType: AgentClientType, runtime: AgentRuntime): Promise<void>;
+export declare function readHostSessionConfig<TExtra extends string = never>(raw: unknown, extraStringFields?: readonly TExtra[]): (SessionWorkspaceConfig & Partial<Record<TExtra, 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>;
+export declare function resolveHostWorkspaceCwd(input: {
+    workspaceOptions: HostWorkspaceResolverOption[];
+    config: {
+        workspaceId?: string;
+        retiredWorkspaceConfig?: boolean;
+    } | null;
+    defaultCwd: string;
+}): string;
+export declare function createConversationMetadataLoader(input: {
+    client: CanonClient;
+    conversationCache: Map<string, CanonConversation>;
+    cacheTtlMs?: number;
+}): {
+    refreshConversationCache(force?: boolean): Promise<void>;
+    getConversationMeta(conversationId: string): Promise<CanonConversation | null>;
+};
+export {};

package/dist/host-runtime.js

@@ -0,0 +1,152 @@
+/**
+ * Host-runtime helpers, inlined from @canonmsg/core.
+ *
+ * These helpers glue Canon host wrappers (Codex, Claude Code) to the Canon
+ * RTDB session/runtime surface. They used to live in
+ * `@canonmsg/core/src/host-runtime/` but were moved into each plugin in
+ * media-parity PR C so core does not have to carry host-specific concerns.
+ *
+ * Keep this file in lockstep with the equivalent file in
+ * `packages/claude-code-plugin/src/host-runtime.ts`. If you change the
+ * behavior here, update that copy too and adjust the shared golden
+ * fixture test (`packages/codex-plugin/src/host-runtime.test.ts`).
+ */
+import { buildBehaviorPolicyLines, buildParticipationHistorySnapshot, buildWorkSessionsPromptLines, mergeWorkSessionContexts, normalizeOptionalString, readSessionWorkspaceConfig, resolveConfiguredWorkspaceCwd, rtdbRead, rtdbWrite, } from '@canonmsg/core';
+export function buildCanonHostPrompt(input) {
+    const resolvedWorkSessions = mergeWorkSessionContexts(input.workSession, input.workSessions);
+    return [
+        `You are connected to Canon messaging through a ${input.hostLabel} host wrapper.`,
+        'Only the last assistant message from this turn will be delivered as the permanent Canon reply.',
+        'Short intermediate assistant messages may be shown as ephemeral status while you work.',
+        ...input.buildInboundContextLines(input.participantContext),
+        ...buildBehaviorPolicyLines(input.behavior),
+        ...buildWorkSessionsPromptLines(resolvedWorkSessions),
+        'Canon participants may be humans or AI agents.',
+        'Honor the Canon behavior policy above when deciding how proactively to participate.',
+        ...(resolvedWorkSessions.length > 0
+            ? ['Honor the Canon work-session context above within its stated disclosure limits.']
+            : []),
+        `Conversation ID: ${input.conversationId}`,
+        '',
+        'New Canon message:',
+        input.content,
+    ].join('\n');
+}
+export function renderCanonHostInboundContent(message) {
+    let content = message.text || '';
+    const attachment = message.attachments?.[0];
+    if (attachment?.kind === 'audio' && attachment.url) {
+        const duration = attachment.durationMs ? ` (${Math.round(attachment.durationMs / 1000)}s)` : '';
+        content = content
+            ? `[Voice message${duration}: ${attachment.url}]\n${content}`
+            : `[Voice message${duration}: ${attachment.url}]`;
+    }
+    else if (attachment?.kind === 'image' && attachment.url) {
+        content = content
+            ? `[Image: ${attachment.url}]\n${content}`
+            : `[Image: ${attachment.url}]`;
+    }
+    else if (attachment?.kind === 'file' && attachment.url) {
+        const label = attachment.fileName || 'File';
+        content = content
+            ? `[File: ${label} ${attachment.url}]\n${content}`
+            : `[File: ${label} ${attachment.url}]`;
+    }
+    else if (message.contentType === 'audio' && message.audioUrl) {
+        const duration = message.audioDurationMs ? ` (${Math.round(message.audioDurationMs / 1000)}s)` : '';
+        content = content
+            ? `[Voice message${duration}: ${message.audioUrl}]\n${content}`
+            : `[Voice message${duration}: ${message.audioUrl}]`;
+    }
+    else if (message.contentType === 'image' && message.imageUrl) {
+        content = content
+            ? `[Image: ${message.imageUrl}]\n${content}`
+            : `[Image: ${message.imageUrl}]`;
+    }
+    return content || '[Empty message]';
+}
+export function buildHydratedInboundContext(input) {
+    const history = buildParticipationHistorySnapshot(input.page?.messages ?? [], input.agentId);
+    return {
+        participantContext: {
+            conversationType: input.conversation?.type ?? 'unknown',
+            memberCount: input.conversation?.memberIds?.length ?? null,
+            senderType: input.message.senderType ?? 'human',
+            senderName: input.senderName,
+            isOwner: input.isOwner,
+            mentionedAgent: Array.isArray(input.message.mentions) && input.message.mentions.includes(input.agentId),
+            recentSenderTypes: history.recentSenderTypes,
+            recentHumanCount: history.recentHumanCount,
+            recentAgentCount: history.recentAgentCount,
+            consecutiveAgentTurns: history.consecutiveAgentTurns,
+            currentAgentStreakStartedByHuman: history.currentAgentStreakStartedByHuman,
+        },
+        behavior: input.page?.behavior ?? input.conversation?.behavior,
+        workSessions: input.page?.workSessions ?? [],
+        hydratedFromPage: input.page != null,
+    };
+}
+export async function publishHostAgentRuntime(agentId, clientType, runtime) {
+    await rtdbWrite(`/agent-runtime/${agentId}`, {
+        clientType,
+        hostMode: true,
+        ...runtime,
+        updatedAt: { '.sv': 'timestamp' },
+    });
+}
+export function readHostSessionConfig(raw, extraStringFields = []) {
+    const baseConfig = readSessionWorkspaceConfig(raw);
+    if (!raw || typeof raw !== 'object') {
+        return baseConfig;
+    }
+    const data = raw;
+    const extraConfig = Object.fromEntries(extraStringFields.flatMap((field) => {
+        const value = normalizeOptionalString(data[field]);
+        return value ? [[field, value]] : [];
+    }));
+    return {
+        ...(baseConfig ?? {}),
+        ...extraConfig,
+    };
+}
+export async function loadHostSessionConfig(input) {
+    const raw = await rtdbRead(`/session-config/${input.conversationId}/${input.agentId}`);
+    return readHostSessionConfig(raw, input.extraStringFields);
+}
+export function resolveHostWorkspaceCwd(input) {
+    return resolveConfiguredWorkspaceCwd(input);
+}
+export function createConversationMetadataLoader(input) {
+    const cacheTtlMs = input.cacheTtlMs ?? 10_000;
+    let conversationCacheLoadedAt = 0;
+    async function refreshConversationCache(force = false) {
+        if (!force
+            && input.conversationCache.size > 0
+            && Date.now() - conversationCacheLoadedAt < cacheTtlMs) {
+            return;
+        }
+        const conversations = await input.client.getConversations();
+        input.conversationCache.clear();
+        for (const conversation of conversations) {
+            input.conversationCache.set(conversation.id, conversation);
+        }
+        conversationCacheLoadedAt = Date.now();
+    }
+    async function getConversationMeta(conversationId) {
+        try {
+            await refreshConversationCache();
+            const cached = input.conversationCache.get(conversationId);
+            if (cached)
+                return cached;
+            await refreshConversationCache(true);
+            return input.conversationCache.get(conversationId) ?? null;
+        }
+        catch {
+            return input.conversationCache.get(conversationId) ?? null;
+        }
+    }
+    return {
+        refreshConversationCache,
+        getConversationMeta,
+    };
+}

package/dist/host.js

@@ -3,7 +3,8 @@ import { setDefaultResultOrder } from 'node:dns';
 setDefaultResultOrder('ipv4first');
 import { randomUUID } from 'node:crypto';
 import { parseArgs } from 'node:util';
-import { buildParticipationHistorySnapshot, buildBehaviorPolicyLines, buildConfiguredWorkspaceOptions, buildPublicWorkspaceOptions, ExecutionEnvironmentError, isEnabledFlag, readSessionWorkspaceConfig, resolveConfiguredWorkspaceCwd, 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 { buildConfiguredWorkspaceOptions, buildPublicWorkspaceOptions, ExecutionEnvironmentError, isEnabledFlag, 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 { buildCanonHostPrompt, buildHydratedInboundContext, createConversationMetadataLoader, loadHostSessionConfig, publishHostAgentRuntime, renderCanonHostInboundContent, resolveHostWorkspaceCwd, } from './host-runtime.js';
 import { buildInboundContextLines, decideAutoReply, } from './inbound-policy.js';
 import { CodexConversationAdapter, } from './adapter.js';
 import { clearStoredThreadId, loadStoredThreadId, saveStoredThreadId, } from './session-store.js';
@@ -37,71 +38,27 @@ function normalizeRuntimeTurnState(value) {
     return null;
 }
 async function publishAgentRuntime(agentId, runtime) {
-    await rtdbWrite(`/agent-runtime/${agentId}`, {
-        clientType: 'codex',
-        hostMode: true,
-        ...runtime,
-        updatedAt: { '.sv': 'timestamp' },
-    });
+    await publishHostAgentRuntime(agentId, 'codex', runtime);
 }
 async function loadSessionConfig(conversationId, agentId) {
-    const raw = await rtdbRead(`/session-config/${conversationId}/${agentId}`);
-    return readSessionWorkspaceConfig(raw);
+    return loadHostSessionConfig({ conversationId, agentId });
 }
 function resolveWorkspaceCwd(config) {
-    return resolveConfiguredWorkspaceCwd({
+    return resolveHostWorkspaceCwd({
         workspaceOptions,
         config,
         defaultCwd: workingDir,
     });
 }
 function buildCanonPrompt(input) {
-    return [
-        'You are connected to Canon messaging through a Codex host wrapper.',
-        'Only the last assistant message from this turn will be delivered as the permanent Canon reply.',
-        'Short intermediate assistant messages may be shown as ephemeral status while you work.',
-        ...buildInboundContextLines(input.participantContext),
-        ...buildBehaviorPolicyLines(input.behavior),
-        'Canon participants may be humans or AI agents.',
-        'Honor the Canon behavior policy above when deciding how proactively to participate.',
-        `Conversation ID: ${input.conversationId}`,
-        '',
-        'New Canon message:',
-        input.content,
-    ].join('\n');
+    return buildCanonHostPrompt({
+        hostLabel: 'Codex',
+        buildInboundContextLines,
+        ...input,
+    });
 }
 function renderInboundContent(message) {
-    let content = message.text || '';
-    const attachment = message.attachments?.[0];
-    if (attachment?.kind === 'audio' && attachment.url) {
-        const duration = attachment.durationMs ? ` (${Math.round(attachment.durationMs / 1000)}s)` : '';
-        content = content
-            ? `[Voice message${duration}: ${attachment.url}]\n${content}`
-            : `[Voice message${duration}: ${attachment.url}]`;
-    }
-    else if (attachment?.kind === 'image' && attachment.url) {
-        content = content
-            ? `[Image: ${attachment.url}]\n${content}`
-            : `[Image: ${attachment.url}]`;
-    }
-    else if (attachment?.kind === 'file' && attachment.url) {
-        const label = attachment.fileName || 'File';
-        content = content
-            ? `[File: ${label} ${attachment.url}]\n${content}`
-            : `[File: ${label} ${attachment.url}]`;
-    }
-    else if (message.contentType === 'audio' && message.audioUrl) {
-        const duration = message.audioDurationMs ? ` (${Math.round(message.audioDurationMs / 1000)}s)` : '';
-        content = content
-            ? `[Voice message${duration}: ${message.audioUrl}]\n${content}`
-            : `[Voice message${duration}: ${message.audioUrl}]`;
-    }
-    else if (message.contentType === 'image' && message.imageUrl) {
-        content = content
-            ? `[Image: ${message.imageUrl}]\n${content}`
-            : `[Image: ${message.imageUrl}]`;
-    }
-    return content || '[Empty message]';
+    return renderCanonHostInboundContent(message);
 }
 function summarizeCommand(command) {
     const trimmed = command.trim();
@@ -173,31 +130,10 @@ async function main() {
     const sessions = new Map();
     const pendingSessionCreations = new Map();
     const conversationCache = new Map();
-    let conversationCacheLoadedAt = 0;
-    async function refreshConversationCache(force = false) {
-        if (!force && conversationCache.size > 0 && Date.now() - conversationCacheLoadedAt < 10_000) {
-            return;
-        }
-        const conversations = await client.getConversations();
-        conversationCache.clear();
-        for (const conversation of conversations) {
-            conversationCache.set(conversation.id, conversation);
-        }
-        conversationCacheLoadedAt = Date.now();
-    }
-    async function getConversationMeta(conversationId) {
-        try {
-            await refreshConversationCache();
-            const cached = conversationCache.get(conversationId);
-            if (cached)
-                return cached;
-            await refreshConversationCache(true);
-            return conversationCache.get(conversationId) ?? null;
-        }
-        catch {
-            return conversationCache.get(conversationId) ?? null;
-        }
-    }
+    const { getConversationMeta } = createConversationMetadataLoader({
+        client,
+        conversationCache,
+    });
     async function loadSenderRuntimeState(conversationId, senderId) {
         try {
             const [turnState, sessionState] = await Promise.all([
@@ -210,25 +146,21 @@ async function main() {
             return null;
         }
     }
-    async function loadParticipantContext(input) {
-        const [conversation, recentMessages] = await Promise.all([
+    async function loadHydratedInboundContext(input) {
+        const [conversation, page] = await Promise.all([
             getConversationMeta(input.conversationId),
-            client.getMessages(input.conversationId, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT).catch(() => []),
+            input.hydratedPage
+                ? Promise.resolve(input.hydratedPage)
+                : client.getMessagesPage(input.conversationId, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT).catch(() => null),
         ]);
-        const history = buildParticipationHistorySnapshot(recentMessages, agentId);
-        return {
-            conversationType: conversation?.type ?? 'unknown',
-            memberCount: conversation?.memberIds?.length ?? null,
-            senderType: input.message.senderType ?? 'human',
+        return buildHydratedInboundContext({
+            agentId,
+            conversation,
+            page,
+            message: input.message,
             senderName: input.senderName,
             isOwner: input.isOwner,
-            mentionedAgent: Array.isArray(input.message.mentions) && input.message.mentions.includes(agentId),
-            recentSenderTypes: history.recentSenderTypes,
-            recentHumanCount: history.recentHumanCount,
-            recentAgentCount: history.recentAgentCount,
-            consecutiveAgentTurns: history.consecutiveAgentTurns,
-            currentAgentStreakStartedByHuman: history.currentAgentStreakStartedByHuman,
-        };
+        });
     }
     function writeState(session) {
         writeSessionState(session.conversationId, agentId, {
@@ -385,14 +317,20 @@ async function main() {
     }
     async function enqueueInboundMessage(input) {
         const content = renderInboundContent(input.message);
-        const conversation = await getConversationMeta(input.conversationId);
-        const behavior = input.behavior ?? conversation?.behavior;
-        const participantContext = await loadParticipantContext({
+        const hydrated = await loadHydratedInboundContext({
             conversationId: input.conversationId,
             message: input.message,
             senderName: input.senderName,
             isOwner: input.isOwner,
+            hydratedPage: input.hydratedPage,
         });
+        const behavior = input.behavior ?? hydrated.behavior;
+        const workSessions = hydrated.hydratedFromPage
+            ? hydrated.workSessions
+            : Array.isArray(input.workSessions)
+                ? input.workSessions
+                : hydrated.workSessions;
+        const participantContext = hydrated.participantContext;
         const autoReply = decideAutoReply(participantContext, behavior);
         if (!autoReply.allow) {
             console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Suppressed auto-reply: ${autoReply.reason}`);
@@ -418,6 +356,8 @@ async function main() {
             conversationId: input.conversationId,
             participantContext,
             behavior,
+            workSession: input.message.workSession,
+            workSessions,
         });
         if (session.running && deliveryIntent === 'interrupt') {
             enqueuePrompt(session, prompt, deliveryIntent, true, input.message.id, shouldMarkAccepted);
@@ -561,6 +501,20 @@ async function main() {
             }
         }
     }
+    let controlStopped = false;
+    let streamConnected = false;
+    let runtimeDescriptor = {
+        defaultWorkspaceId: workspaceOptions[0]?.id,
+        ...(typeof args.model === 'string' ? { defaultModel: args.model } : {}),
+        availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
+    };
+    const publishRuntimeHeartbeat = async () => {
+        if (!streamConnected)
+            return;
+        await publishAgentRuntime(agentId, runtimeDescriptor).catch((error) => {
+            console.error('[canon-codex] Failed to publish agent runtime:', error);
+        });
+    };
     const stream = new CanonStream({
         apiKey,
         agentId,
@@ -575,22 +529,34 @@ async function main() {
                     senderName: message.senderName || message.senderId,
                     isOwner: message.isOwner ?? (ownerId != null && message.senderId === ownerId),
                     behavior: payload.behavior,
+                    workSessions: payload.workSessions,
                 });
             },
-            onConnected: () => console.error('[canon-codex] SSE connected'),
-            onDisconnected: () => console.error('[canon-codex] SSE disconnected'),
+            onConnected: () => {
+                streamConnected = true;
+                void publishRuntimeHeartbeat();
+                console.error('[canon-codex] SSE connected');
+            },
+            onDisconnected: () => {
+                streamConnected = false;
+                rtdbWrite(`/agent-runtime/${agentId}`, null).catch(() => { });
+                console.error('[canon-codex] SSE disconnected');
+            },
             onError: (error) => console.error(`[canon-codex] SSE error: ${error.message}`),
         },
     });
     try {
-        await publishAgentRuntime(agentId, {
+        runtimeDescriptor = {
             defaultWorkspaceId: workspaceOptions[0]?.id,
             ...(typeof args.model === 'string' ? { defaultModel: args.model } : {}),
             availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
-        });
+        };
     }
-    catch (error) {
-        console.error('[canon-codex] Failed to publish agent runtime:', error);
+    catch {
+        runtimeDescriptor = {
+            defaultWorkspaceId: workspaceOptions[0]?.id,
+            availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
+        };
     }
     try {
         const conversations = await client.getConversations();
@@ -625,6 +591,8 @@ async function main() {
                 senderName: latestMessage.senderId,
                 isOwner: ownerId != null && latestMessage.senderId === ownerId,
                 behavior: latestPage.behavior,
+                workSessions: latestPage.workSessions,
+                hydratedPage: latestPage,
             });
         }
     }
@@ -634,7 +602,6 @@ async function main() {
     await stream.start().catch((error) => {
         console.error('[canon-codex] SSE start error:', error instanceof Error ? error.message : error);
     });
-    let controlStopped = false;
     const lastSeenControl = new Map();
     const lastSeenSignal = new Map();
     const pollControl = async () => {
@@ -700,6 +667,7 @@ async function main() {
             writeState(session);
             writeTurn(session);
         }
+        void publishRuntimeHeartbeat();
     }, HEARTBEAT_MS);
     const idleCheck = setInterval(() => {
         const now = Date.now();
@@ -719,6 +687,7 @@ async function main() {
         clearInterval(heartbeat);
         clearInterval(idleCheck);
         stream.stop();
+        await rtdbWrite(`/agent-runtime/${agentId}`, null).catch(() => { });
         for (const session of [...sessions.values()]) {
             await session.adapter.interrupt().catch(() => { });
             closeSession(session.conversationId);

package/dist/register.js

@@ -23,6 +23,14 @@ if (!values.name || !values.description || !values.phone) {
     process.exit(1);
 }
 const profileName = values.profile || values.name.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
+let existingAgentId;
+try {
+    const profiles = JSON.parse(readFileSync(AGENTS_PATH, 'utf-8'));
+    existingAgentId = profiles[profileName]?.agentId;
+}
+catch {
+    // No existing profile state.
+}
 console.log(`Registering Codex agent "${values.name}" (profile: ${profileName})...`);
 const result = await registerAndWaitForApproval({
     name: values.name,
@@ -31,6 +39,7 @@ const result = await registerAndWaitForApproval({
     developerInfo: 'Codex host plugin',
     clientType: 'codex',
     baseUrl: values['base-url'],
+    requestedAgentId: existingAgentId,
 }, {
     onSubmitted: (requestId) => {
         console.log(`Registration submitted (request ID: ${requestId}).`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/host.js",
@@ -22,7 +22,7 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@canonmsg/core": "^0.4.0"
+    "@canonmsg/core": "^0.7.0"
   },
   "engines": {
     "node": ">=18.0.0"