@canonmsg/codex-plugin 0.9.1 → 0.9.3

package/dist/host.js

@@ -3,8 +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 { buildConfiguredWorkspaceOptionsWithRoots, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, EXECUTION_ENVIRONMENT_MODES, ExecutionEnvironmentError, CanonClient, CanonStream, clearSessionState, clearTurnState, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, FINAL_MESSAGE_HANDOFF_MS, getActiveProfileLock, initRTDBAuth, buildLocalRuntimeId, heartbeatLocalRuntimeEntry, loadRuntimeSessionState, markLocalRuntimeStopped, normalizeTurnMetadata, normalizeTurnState, prepareConversationEnvironment, releaseConversationEnvironment, resolveCanonAgent, rtdbRead, rtdbWrite, writeRuntimeInfo, shouldTriggerAgentTurn, saveRuntimeSessionState, writeSessionState, writeTurnState, upsertLocalRuntimeEntry, } from '@canonmsg/core';
-import { buildCanonHostPrompt, buildHydratedInboundContext, createConversationMetadataLoader, loadHostSessionConfig, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, resolveHostWorkspaceCwd, } from './host-runtime.js';
+import { buildCanonHostPrompt, buildConfiguredWorkspaceOptionsWithRoots, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, 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, shouldTriggerAgentTurn, saveRuntimeSessionState, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, resolveHostWorkspaceCwd, upsertLocalRuntimeEntry, } from '@canonmsg/core';
 import { buildInboundContextLines, decideAutoReply, } from './inbound-policy.js';
 import { CodexConversationAdapter, } from './adapter.js';
 import { clearStoredThreadId, loadStoredThreadId, saveStoredThreadId, } from './session-store.js';
@@ -26,63 +25,15 @@ 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',
-            },
-        ],
+    return buildFirstPartyCodingRuntimeDescriptor({
+        clientType: 'codex',
+        models: input.models,
+        workspaces: input.workspaces,
+        workspaceRoots: input.workspaceRoots,
+        executionModes: input.executionModes,
+        permissionModes: input.permissionModes,
+        defaultPermissionMode: input.defaultPermissionMode,
+        streamingTextMode: 'snapshot',
         actions: [
             {
                 id: 'stop',
@@ -105,25 +56,13 @@ function buildCodexRuntimeDescriptor(input) {
                 dispatch: { kind: 'signal', signal: 'stop_and_drop' },
             },
         ],
-        workspaceRoots: input.workspaceRoots,
-        supportsInterrupt: true,
-        streamingTextMode: 'snapshot',
-    };
+    });
 }
 function normalizeRuntimeTurnState(value) {
     const normalizedTurn = normalizeTurnState(value);
     if (normalizedTurn) {
         return { state: normalizedTurn.state };
     }
-    if (!value || typeof value !== 'object')
-        return null;
-    const state = value.state;
-    if (state === 'running') {
-        return { state: 'streaming' };
-    }
-    if (state === 'requires_action') {
-        return { state: 'waiting_input' };
-    }
     return null;
 }
 async function publishAgentRuntime(agentId, runtime) {
@@ -268,6 +207,11 @@ export async function main() {
         lastStartedAt: new Date().toISOString(),
         lastHeartbeatAt: new Date().toISOString(),
     });
+    const runtimeState = createRuntimeStatePublisher({
+        agentId,
+        clientType: 'codex',
+        hostMode: true,
+    });
     const sessions = new Map();
     const pendingSessionCreations = new Map();
     const conversationCache = new Map();
@@ -294,11 +238,7 @@ export async function main() {
     }
     async function loadSenderRuntimeState(conversationId, senderId) {
         try {
-            const [turnState, sessionState] = await Promise.all([
-                rtdbRead(`/turn-state/${conversationId}/${senderId}`),
-                rtdbRead(`/session-state/${conversationId}/${senderId}`),
-            ]);
-            return normalizeRuntimeTurnState(turnState) ?? normalizeRuntimeTurnState(sessionState);
+            return normalizeRuntimeTurnState(await rtdbRead(`/turn-state/${conversationId}/${senderId}`));
         }
         catch {
             return null;
@@ -321,7 +261,7 @@ export async function main() {
         });
     }
     function writeState(session) {
-        writeSessionState(session.conversationId, agentId, {
+        runtimeState.writeSessionState(session.conversationId, {
             lastError: session.state.lastError,
             model: session.state.model,
             cwd: session.cwd,
@@ -333,12 +273,11 @@ export async function main() {
                 : {}),
             hostMode: true,
             clientType: 'codex',
-            state: session.state.state,
             isActive: true,
         }).catch(() => { });
     }
     function writeTurn(session) {
-        writeTurnState(session.conversationId, agentId, {
+        runtimeState.writeTurnState(session.conversationId, {
             turnId: session.currentTurnId,
             state: session.turnState,
             queueDepth: session.queue.length,
@@ -357,7 +296,7 @@ export async function main() {
         await client.updateMessageDisposition(conversationId, sourceMessageId, 'accepted_now').catch(() => { });
     }
     function clearStreaming(conversationId) {
-        rtdbWrite(`/streaming/${conversationId}/${agentId}`, null).catch(() => { });
+        runtimeState.clearStreaming(conversationId).catch(() => { });
     }
     async function handoffFinalMessage(conversationId) {
         await sleep(FINAL_MESSAGE_HANDOFF_MS);
@@ -393,8 +332,8 @@ export async function main() {
         stopVisibleWorkSignal(session);
         releaseConversationEnvironment(session.environment);
         clearStreaming(conversationId);
-        clearSessionState(conversationId, agentId).catch(() => { });
-        clearTurnState(conversationId, agentId).catch(() => { });
+        runtimeState.clearSessionState(conversationId).catch(() => { });
+        runtimeState.clearTurnState(conversationId).catch(() => { });
         client.setTyping(conversationId, false).catch(() => { });
         sessions.delete(conversationId);
     }
@@ -605,10 +544,9 @@ export async function main() {
         writeState(session);
         writeTurn(session);
         startVisibleWorkSignal(session);
-        rtdbWrite(`/streaming/${session.conversationId}/${agentId}`, {
+        runtimeState.writeStreaming(session.conversationId, {
             text: 'Thinking…',
             status: 'thinking',
-            updatedAt: { '.sv': 'timestamp' },
         }).catch(() => { });
         try {
             const turnImagePaths = nextTurn.imagePaths ?? [];
@@ -624,10 +562,9 @@ export async function main() {
                     writeTurn(session);
                     stopVisibleWorkSignal(session);
                     client.setTyping(session.conversationId, false).catch(() => { });
-                    rtdbWrite(`/streaming/${session.conversationId}/${agentId}`, {
+                    runtimeState.writeStreaming(session.conversationId, {
                         text: event.text,
                         status: 'streaming',
-                        updatedAt: { '.sv': 'timestamp' },
                     }).catch(() => { });
                     return;
                 }
@@ -635,10 +572,9 @@ export async function main() {
                     session.turnState = 'tool';
                     writeTurn(session);
                     startVisibleWorkSignal(session);
-                    rtdbWrite(`/streaming/${session.conversationId}/${agentId}`, {
+                    runtimeState.writeStreaming(session.conversationId, {
                         text: summarizeCommand(event.command),
                         status: 'tool',
-                        updatedAt: { '.sv': 'timestamp' },
                     }).catch(() => { });
                     return;
                 }
@@ -772,6 +708,7 @@ export async function main() {
             runtime: runtimeDescriptor,
             workspaceOptions,
             defaultCwd: workingDir,
+            extraSessionConfigFields: ['permissionMode'],
             liveSessionConfigByConversation: new Map(Array.from(sessions.values()).map((session) => {
                 const workspaceId = resolveWorkspaceIdForBaseCwd(session.environment.baseCwd);
                 return [
@@ -793,15 +730,11 @@ export async function main() {
                 ? 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: runtimeDescriptor.runtimeDescriptor ?? buildCodexRuntimeDescriptor({
-                    models: runtimeDescriptor.availableModels ?? [],
-                    workspaces: buildPublicWorkspaceOptions(workspaceOptions),
-                    workspaceRoots: workspaceRootMetadata,
-                    executionModes: hostAvailableExecutionModes,
-                    permissionModes: [...codexPermissionEnvelope.availablePermissionModes],
-                    defaultPermissionMode: codexPermissionEnvelope.defaultPermissionMode,
-                }),
+                descriptor,
                 surfaceMode: 'host',
                 statusItems: [
                     {
@@ -836,7 +769,7 @@ export async function main() {
                     '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);
+            await runtimeState.writeRuntimeInfo(conversationId, payload);
         })).catch((error) => {
             console.error('[canon-codex] Failed to publish runtime info:', error);
         });
@@ -872,7 +805,7 @@ export async function main() {
             },
             onDisconnected: () => {
                 streamConnected = false;
-                rtdbWrite(`/agent-runtime/${agentId}`, null).catch(() => { });
+                runtimeState.clearAgentRuntime().catch(() => { });
                 console.error('[canon-codex] SSE disconnected');
             },
             onError: (error) => console.error(`[canon-codex] SSE error: ${error.message}`),
@@ -924,8 +857,8 @@ export async function main() {
             knownConversationIds.add(conversation.id);
             conversationCache.set(conversation.id, conversation);
             clearStreaming(conversation.id);
-            clearSessionState(conversation.id, agentId).catch(() => { });
-            clearTurnState(conversation.id, agentId).catch(() => { });
+            runtimeState.clearSessionState(conversation.id).catch(() => { });
+            runtimeState.clearTurnState(conversation.id).catch(() => { });
         }
         for (const conversation of conversations) {
             const cursor = loadRuntimeSessionState(runtimeId, {
@@ -1066,7 +999,7 @@ export async function main() {
         clearInterval(heartbeat);
         clearInterval(idleCheck);
         stream.stop();
-        await rtdbWrite(`/agent-runtime/${agentId}`, null).catch(() => { });
+        await runtimeState.clearAgentRuntime().catch(() => { });
         for (const session of [...sessions.values()]) {
             await session.adapter.interrupt().catch(() => { });
             closeSession(session.conversationId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "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.10.1",
-    "@canonmsg/core": "^0.13.0"
+    "@canonmsg/agent-sdk": "^1.0.0",
+    "@canonmsg/core": "^0.15.0"
   },
   "engines": {
     "node": ">=18.0.0"

package/dist/host-runtime.d.ts

@@ -1,133 +0,0 @@
-/**
- * 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;
-    attachments?: CanonMessage['attachments'];
-    senderType?: CanonMessage['senderType'];
-    mentions?: string[] | null;
-    contactCard?: CanonMessage['contactCard'];
-};
-interface HostWorkspaceResolverOption {
-    id: string;
-    cwd: string;
-}
-export declare const HOST_ADMISSION_ACTION_CAPABILITIES: Readonly<{
-    canStartDirectConversation: false;
-    canSendContactRequest: false;
-    canApprovePendingContactRequests: false;
-    canRejectPendingContactRequests: false;
-}>;
-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;
-/**
- * Render the **text portion** of an inbound Canon message. Images are
- * referenced by short placeholders — their actual bytes are delivered to the
- * host as native vision/media inputs (Codex `-i <file>`, Anthropic image
- * blocks). URLs are intentionally *not* inlined, since the harness never
- * needs to refetch and earlier `[Image: <url>]` inlining caused vision
- * models to see a string about an image instead of the image itself.
- *
- * `materialized` may be passed so non-image attachments can reference a
- * local path the agent can Read. Without it we fall back to an unadorned
- * placeholder; the vision path still works because image args carry the
- * file path directly.
- */
-export declare function renderCanonHostInboundContent(message: HostInboundMessage, materialized?: ReadonlyArray<{
-    kind: 'image' | 'audio' | 'file';
-    path: string;
-    fileName?: string;
-    durationMs?: number;
-    index: number;
-}>): 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 publishHostSessionSnapshots(input: {
-    conversationIds: string[];
-    agentId: string;
-    clientType: AgentClientType;
-    runtime: AgentRuntime;
-    workspaceOptions: HostWorkspaceResolverOption[];
-    defaultCwd: string;
-    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>> & {
-    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>> & {
-    runtimeControlValues?: Record<string, 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

@@ -1,263 +0,0 @@
-/**
- * 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 { buildAgentSessionSnapshot, buildConversationWorktreeSpec, buildBehaviorPolicyLines, buildParticipationHistorySnapshot, buildWorkSessionsPromptLines, mergeWorkSessionContexts, normalizeOptionalString, patchAgentSessionSnapshot, readSessionWorkspaceConfig, resolveConfiguredWorkspaceCwd, rtdbRead, rtdbWrite, } from '@canonmsg/core';
-export const HOST_ADMISSION_ACTION_CAPABILITIES = Object.freeze({
-    canStartDirectConversation: false,
-    canSendContactRequest: false,
-    canApprovePendingContactRequests: false,
-    canRejectPendingContactRequests: false,
-});
-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');
-}
-/**
- * Render the **text portion** of an inbound Canon message. Images are
- * referenced by short placeholders — their actual bytes are delivered to the
- * host as native vision/media inputs (Codex `-i <file>`, Anthropic image
- * blocks). URLs are intentionally *not* inlined, since the harness never
- * needs to refetch and earlier `[Image: <url>]` inlining caused vision
- * models to see a string about an image instead of the image itself.
- *
- * `materialized` may be passed so non-image attachments can reference a
- * local path the agent can Read. Without it we fall back to an unadorned
- * placeholder; the vision path still works because image args carry the
- * file path directly.
- */
-export function renderCanonHostInboundContent(message, materialized) {
-    const body = message.text || '';
-    const placeholders = [];
-    const attachments = message.attachments ?? [];
-    for (let i = 0; i < attachments.length; i += 1) {
-        const att = attachments[i];
-        const mat = materialized?.find((m) => m.index === i) ?? null;
-        placeholders.push(describeAttachment(att, mat));
-    }
-    if (message.contentType === 'contact_card' && message.contactCard) {
-        placeholders.push(describeContactCard(message.contactCard));
-    }
-    const rendered = [...placeholders, body].filter(Boolean).join('\n');
-    return rendered || '[Empty message]';
-}
-function describeContactCard(card) {
-    const parts = [`${card.userType} · userId: ${card.userId}`];
-    if (card.ownerName)
-        parts.push(`owner: ${card.ownerName}`);
-    if (card.about)
-        parts.push(`about: ${card.about}`);
-    const identity = `📇 Contact card: "${card.displayName}" (${parts.join(' · ')}).`;
-    const missingCapabilities = [
-        !HOST_ADMISSION_ACTION_CAPABILITIES.canStartDirectConversation
-            ? 'start a direct conversation'
-            : null,
-        !HOST_ADMISSION_ACTION_CAPABILITIES.canSendContactRequest
-            ? 'send a contact request'
-            : null,
-        !HOST_ADMISSION_ACTION_CAPABILITIES.canApprovePendingContactRequests
-            ? 'approve pending requests'
-            : null,
-        !HOST_ADMISSION_ACTION_CAPABILITIES.canRejectPendingContactRequests
-            ? 'reject pending requests'
-            : null,
-    ].filter(Boolean).join(', ');
-    const hint = `This host can inspect the card, but Canon admission actions are missing here. Missing capabilities: ${missingCapabilities}. Use another Canon surface for userId ${card.userId}.`;
-    return `${identity}\n${hint}`;
-}
-function describeAttachment(attachment, materialized) {
-    if (attachment.kind === 'image') {
-        return '[Image attached]';
-    }
-    if (attachment.kind === 'audio') {
-        const durationMs = materialized?.durationMs ?? attachment.durationMs;
-        const duration = durationMs ? ` (${Math.round(durationMs / 1000)}s)` : '';
-        const ref = materialized?.path ? ` ${materialized.path}` : '';
-        return `[Voice message${duration}${ref}]`;
-    }
-    // file
-    const label = materialized?.fileName ?? attachment.fileName ?? 'File';
-    const ref = materialized?.path ? ` ${materialized.path}` : '';
-    return `[File: ${label}${ref}]`;
-}
-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 async function publishHostSessionSnapshots(input) {
-    if (input.conversationIds.length === 0) {
-        return;
-    }
-    await Promise.all(input.conversationIds.map(async (conversationId) => {
-        const persistedConfig = await loadHostSessionConfig({
-            conversationId,
-            agentId: input.agentId,
-            extraStringFields: ['permissionMode'],
-        });
-        const liveConfig = input.liveSessionConfigByConversation?.get(conversationId) ?? null;
-        const mergedConfig = {
-            ...(persistedConfig ?? {}),
-            ...(liveConfig ?? {}),
-        };
-        const snapshot = buildAgentSessionSnapshot({
-            conversationId,
-            agentId: input.agentId,
-            runtime: {
-                ...input.runtime,
-                clientType: input.clientType,
-                hostMode: true,
-            },
-            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 } : {}),
-            },
-            lastHeartbeatAt: undefined,
-        });
-        let executionBranch = liveConfig?.executionBranch ?? null;
-        if (!executionBranch && snapshot.executionMode === 'worktree' && snapshot.workspaceId) {
-            const workspace = input.workspaceOptions.find((option) => option.id === snapshot.workspaceId);
-            if (workspace) {
-                executionBranch = buildConversationWorktreeSpec({
-                    agentId: input.agentId,
-                    conversationId,
-                    workspaceCwd: workspace.cwd,
-                }).branch;
-            }
-        }
-        return patchAgentSessionSnapshot(conversationId, input.agentId, {
-            clientType: input.clientType,
-            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,
-            modelOptions: snapshot.modelOptions,
-            permissionModeOptions: snapshot.permissionModeOptions,
-            workspaceOptions: snapshot.workspaceOptions,
-            availableExecutionModes: snapshot.availableExecutionModes,
-            lastHeartbeatAt: { '.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]] : [];
-    }));
-    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) {
-    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,
-    };
-}