@canonmsg/claude-code-plugin 0.21.2 → 0.23.0

package/dist/inbound-policy.d.ts

@@ -0,0 +1,22 @@
+import { type CanonGroupContext, type CanonGroupContextMode, type CanonConversation, type ResolvedAgentBehaviorPolicy } from '@canonmsg/core';
+export interface InboundParticipantContext {
+    conversationType: CanonConversation['type'] | 'unknown';
+    memberCount: number | null;
+    senderType: 'human' | 'ai_agent';
+    senderName: string;
+    isOwner: boolean;
+    mentionedAgent: boolean;
+    groupContext?: CanonGroupContext;
+    groupContextMode?: CanonGroupContextMode;
+    recentSenderTypes: Array<'human' | 'ai_agent'>;
+    recentHumanCount: number;
+    recentAgentCount: number;
+    consecutiveAgentTurns: number;
+    currentAgentStreakStartedByHuman: boolean;
+}
+export interface AutoReplyDecision {
+    allow: boolean;
+    reason: string;
+}
+export declare function buildInboundContextLines(context: InboundParticipantContext): string[];
+export declare function decideAutoReply(context: InboundParticipantContext, behavior?: ResolvedAgentBehaviorPolicy | null): AutoReplyDecision;

package/dist/inbound-policy.js

@@ -0,0 +1,46 @@
+import { buildCompactGroupContextLines, evaluateParticipationPolicy, resolveAgentBehaviorPolicy, } from '@canonmsg/core';
+function formatRecentSenders(senderTypes) {
+    if (senderTypes.length === 0)
+        return 'none';
+    return senderTypes.map((senderType) => (senderType === 'ai_agent' ? 'agent' : 'human')).join(' -> ');
+}
+export function buildInboundContextLines(context) {
+    const conversationTypeLabel = context.conversationType === 'unknown'
+        ? 'unknown'
+        : `${context.conversationType}${context.memberCount ? ` (${context.memberCount} members)` : ''}`;
+    const senderRole = context.isOwner
+        ? 'The latest sender is the verified human owner of this Canon agent.'
+        : context.senderType === 'ai_agent'
+            ? 'The latest sender is another AI agent in Canon.'
+            : 'The latest sender is a human Canon participant.';
+    return [
+        senderRole,
+        `Latest sender name: ${context.senderName}`,
+        `Latest sender type: ${context.senderType}`,
+        `Conversation type: ${conversationTypeLabel}`,
+        ...(context.groupContext && context.groupContextMode
+            ? buildCompactGroupContextLines(context.groupContext, context.groupContextMode)
+            : []),
+        `Directly addressed to this agent: ${context.mentionedAgent ? 'yes' : 'no'}`,
+        `Recent sender pattern: ${formatRecentSenders(context.recentSenderTypes)}`,
+        `Recent human messages: ${context.recentHumanCount}`,
+        `Recent agent messages: ${context.recentAgentCount}`,
+        `Consecutive recent agent turns: ${context.consecutiveAgentTurns}`,
+        `Current agent streak started after a human message: ${context.currentAgentStreakStartedByHuman ? 'yes' : 'no'}`,
+    ];
+}
+export function decideAutoReply(context, behavior) {
+    const decision = evaluateParticipationPolicy(behavior ?? resolveAgentBehaviorPolicy(), {
+        conversationType: context.conversationType,
+        senderType: context.senderType,
+        isOwner: context.isOwner,
+        mentionedAgent: context.mentionedAgent,
+        recentHumanCount: context.recentHumanCount,
+        consecutiveAgentTurns: context.consecutiveAgentTurns,
+        currentAgentStreakStartedByHuman: context.currentAgentStreakStartedByHuman,
+    });
+    return {
+        allow: decision.allow,
+        reason: decision.reason,
+    };
+}

package/dist/mcp-args.d.ts

@@ -1,4 +1,4 @@
-import type { DirectSessionSelection, SendContextualMessageOptions } from '@canonmsg/core/contract';
+import type { DirectSessionSelection, SendContextualMessageOptions } from '@canonmsg/core';
 export type McpParseResult<T> = {
     ok: true;
     value: T;

package/dist/register.js

@@ -9,47 +9,10 @@ import { setDefaultResultOrder } from 'node:dns';
  *
  * On approval, saves the agent to ~/.canon/agents.json under the profile name.
  */
-import { ackRegistrationApprovalWith, resolveCanonBaseUrl, runRegistrationFlow, } from '@canonmsg/core/contract';
-import { clearPendingRegistration, getOrCreatePendingRegistration, updatePendingRegistration, upsertAgentProfile, AGENTS_PATH, } from '@canonmsg/core/local';
-import { resolvePackagedBridgeBin } from './bridge-bin.js';
-import { connectBridge } from '@canonmsg/framework';
+import { ackRegistrationApproval, clearPendingRegistration, getOrCreatePendingRegistration, registerAndWaitForApproval, updatePendingRegistration, upsertAgentProfile, AGENTS_PATH, } from '@canonmsg/core';
 import { readFileSync } from 'node:fs';
 import { parseArgs } from 'node:util';
 import { runCli } from './cli-entry.js';
-/**
- * Registration rides the bridge (Phase 6, same shape as the Hermes port): a
- * short-lived PRE-IDENTITY registration daemon (offline stub +
- * CANON_BRIDGE_REGISTRATION_BASE_URL, managed-child so it dies with this
- * process) serves the three unauthenticated §B10 routes over JSON-RPC.
- */
-async function openRegistrationBridge(baseUrl) {
-    return connectBridge({
-        profile: 'registration',
-        mode: 'managed-child',
-        ...(resolvePackagedBridgeBin() ? { binPath: resolvePackagedBridgeBin() } : {}),
-        env: {
-            ...process.env,
-            CANON_BRIDGE_AGENT_ID: 'canon-registration',
-            CANON_BRIDGE_REGISTRATION_BASE_URL: baseUrl,
-        },
-        hello: { clientType: 'claude-code', wantFamilies: [] },
-    });
-}
-function bridgeRegistrationTransport(bridge) {
-    return {
-        register: (_baseUrl, body) => bridge.client.call('register', body),
-        checkStatus: (_baseUrl, requestId, pollToken) => bridge.client.call('getRegistrationStatus', {
-            requestId,
-            ...(pollToken ? { pollToken } : {}),
-        }),
-        ackRegistrationStatus: async (_baseUrl, requestId, pollToken) => {
-            await bridge.client.call('ackRegistrationStatus', {
-                requestId,
-                ...(pollToken ? { pollToken } : {}),
-            });
-        },
-    };
-}
 const HELP = `canon-register — register or reconnect a Claude Code agent in Canon
 
 USAGE
@@ -99,39 +62,29 @@ export async function main() {
     }
     console.log(`Registering agent "${values.name}" (profile: ${profileName})...`);
     const pending = getOrCreatePendingRegistration(profileName, 'claude-code');
-    const baseUrl = resolveCanonBaseUrl(values['base-url']);
-    const bridge = await openRegistrationBridge(baseUrl);
-    const transport = bridgeRegistrationTransport(bridge);
-    let result;
-    try {
-        result = await runRegistrationFlow({
-            name: values.name,
-            description: values.description,
-            ownerPhone: values.phone,
-            developerInfo: 'Claude Code plugin',
-            clientType: 'claude-code',
-            baseUrl: values['base-url'],
-            requestedAgentId: existingAgentId,
-            localRegistrationId: pending.localRegistrationId,
-        }, transport, {
-            onSubmitted: (requestId, pollToken) => {
-                updatePendingRegistration(profileName, {
-                    requestId,
-                    pollToken,
-                    clientType: 'claude-code',
-                });
-                console.log(`Registration submitted (request ID: ${requestId}).`);
-                console.log('Waiting for approval in Canon app...');
-            },
-            onPollUpdate: () => {
-                process.stdout.write('.');
-            },
-        });
-    }
-    catch (error) {
-        bridge.client.close();
-        throw error;
-    }
+    const result = await registerAndWaitForApproval({
+        name: values.name,
+        description: values.description,
+        ownerPhone: values.phone,
+        developerInfo: 'Claude Code plugin',
+        clientType: 'claude-code',
+        baseUrl: values['base-url'],
+        requestedAgentId: existingAgentId,
+        localRegistrationId: pending.localRegistrationId,
+    }, {
+        onSubmitted: (requestId, pollToken) => {
+            updatePendingRegistration(profileName, {
+                requestId,
+                pollToken,
+                clientType: 'claude-code',
+            });
+            console.log(`Registration submitted (request ID: ${requestId}).`);
+            console.log('Waiting for approval in Canon app...');
+        },
+        onPollUpdate: () => {
+            process.stdout.write('.');
+        },
+    });
     console.log(''); // newline after dots
     switch (result.status) {
         case 'approved': {
@@ -148,7 +101,7 @@ export async function main() {
                 ...(typeof values['base-url'] === 'string' ? { baseUrl: values['base-url'] } : {}),
             });
             if (result.requestId) {
-                await ackRegistrationApprovalWith(transport, values['base-url'], result.requestId, result.pollToken);
+                await ackRegistrationApproval(values['base-url'], result.requestId, result.pollToken);
             }
             clearPendingRegistration(profileName);
             console.log(`Approved! Agent: ${result.agentName} (${result.agentId})`);
@@ -168,7 +121,6 @@ export async function main() {
             process.exit(1);
             break;
     }
-    bridge.client.close();
 }
 runCli(import.meta.url, main, (error) => {
     console.error('[canon-register] Fatal error:', error);

package/dist/server.js

@@ -10,7 +10,7 @@ import { setDefaultResultOrder } from 'node:dns';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { CanonClient, CanonStream, ApprovalManager, buildLocalRuntimeId, markLocalRuntimeStopped, loadProfiles, isProfileLocked, resolveCanonAgent, releaseLock, upsertLocalRuntimeEntry, initRTDBAuth, renderCanonHostInboundContent, } from '@canonmsg/core';
+import { CanonClient, CanonStream, ApprovalManager, buildLocalRuntimeId, getActiveProfileLock, markLocalRuntimeStopped, loadProfiles, isProfileLocked, resolveCanonAgent, getActiveProfile, releaseLock, upsertLocalRuntimeEntry, initRTDBAuth, writeSessionState, clearSessionState, renderCanonHostInboundContent, } from '@canonmsg/core';
 import { materializeMessageMedia, sendMediaFileMessage, } from '@canonmsg/agent-sdk';
 import { ApprovalHttpServer } from './approval-server.js';
 import { runCli } from './cli-entry.js';
@@ -34,16 +34,6 @@ const server = new Server({ name: 'canon-channel', version: '0.1.0' }, {
     },
 });
 let client = null;
-// Scoped RTDB handle for this channel server's single agent. Held alongside
-// the other per-process singletons (client, stream, ...) so both startChannel
-// and the shutdown handler in main() write session state as this agent — not
-// through any module-global default.
-let rtdb = null;
-// The one agent profile this server resolved+locked, and its lock handle.
-// Held here (not via a core module-global) so the list_agents tool handler and
-// the shutdown/error paths — all outside startChannel's scope — can read them.
-let activeProfile = null;
-let activeLockHandle = null;
 let stream = null;
 let agentContext = null;
 let approvalManager = null;
@@ -396,7 +386,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     profile: name,
                     agentName: p.agentName,
                     agentId: p.agentId,
-                    status: activeProfile === name ? 'active (this session)' : lock.locked ? `in use (PID ${lock.pid})` : 'available',
+                    status: getActiveProfile() === name ? 'active (this session)' : lock.locked ? `in use (PID ${lock.pid})` : 'available',
                 };
             });
             if (entries.length === 0) {
@@ -557,8 +547,6 @@ async function startChannel() {
         profile = resolved.profile;
         baseUrl = resolved.baseUrl;
         profileAgentName = resolved.agentName;
-        activeProfile = resolved.profile;
-        activeLockHandle = resolved.lockHandle ?? null;
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : err);
@@ -589,7 +577,7 @@ async function startChannel() {
         }
     }
     // Initialize RTDB auth for session state reporting
-    rtdb = initRTDBAuth(client);
+    initRTDBAuth(client);
     const runtimeId = buildLocalRuntimeId({
         runtime: 'claude-code',
         profile,
@@ -624,7 +612,7 @@ async function startChannel() {
     // Write initial session state
     const initialState = { cwd: process.cwd(), isActive: true };
     for (const convoId of conversationCache.keys()) {
-        rtdb.writeSessionState(convoId, agentId, initialState).catch((err) => console.error(`[canon] Failed to write initial state for ${convoId}:`, err));
+        writeSessionState(convoId, agentId, initialState).catch((err) => console.error(`[canon] Failed to write initial state for ${convoId}:`, err));
     }
     // Start SSE stream
     stream = new CanonStream({
@@ -677,10 +665,9 @@ export async function main() {
     // Graceful shutdown — release agent lock and clear session state
     const shutdown = () => {
         // Mark all conversations as inactive
-        if (agentContext && rtdb) {
-            const scopedRtdb = rtdb;
+        if (agentContext) {
             for (const convoId of conversationCache.keys()) {
-                scopedRtdb.clearSessionState(convoId, agentContext.agentId).catch(() => { });
+                clearSessionState(convoId, agentContext.agentId).catch(() => { });
             }
         }
         approvalManager?.dispose();
@@ -688,14 +675,15 @@ export async function main() {
         stream?.stop();
         const runtimeId = buildLocalRuntimeId({
             runtime: 'claude-code',
-            profile: activeProfile,
+            profile: getActiveProfile(),
             cwd: process.cwd(),
             launchCommand: ['canon-channel-server'],
         });
         markLocalRuntimeStopped(runtimeId);
-        if (activeProfile)
-            releaseLock(activeProfile);
-        activeLockHandle?.release();
+        const ap = getActiveProfile();
+        if (ap)
+            releaseLock(ap);
+        getActiveProfileLock()?.release();
         process.exit(0);
     };
     process.on('SIGINT', shutdown);

package/dist/session-state.d.ts

@@ -1,8 +1,6 @@
-import type { Query, SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
-import type { DeliveryIntent, ModelOption, TurnLifecycleState } from '@canonmsg/core/contract';
-import type { TurnArtifactSnapshot } from '@canonmsg/agent-host';
-import { type ClaudeEffortLevel } from './session-defaults.js';
-export type { ClaudeEffortLevel } from './session-defaults.js';
+import type { SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
+import type { DeliveryIntent, ModelOption, TurnLifecycleState } from '@canonmsg/core';
+import type { TurnArtifactSnapshot } from '@canonmsg/coding-agent-host';
 export type ClaudeInputKind = 'seed' | 'canon';
 export type ClaudeArtifactRoutingMode = 'workspace-generated' | 'disabled';
 export interface ClaudeInputEnvelope {
@@ -21,47 +19,6 @@ export interface ClaudeRuntimeControlError {
     message: string;
     updatedAt: number;
 }
-export type ClaudePermissionMode = Parameters<Query['setPermissionMode']>[0];
-export interface ClaudeSessionControl {
-    model?: string;
-    permissionMode?: string;
-    effort?: string;
-    runtimeControlValues?: Record<string, string>;
-    updatedAt?: number;
-    updatedBy?: string;
-}
-export interface ClaudeHostSessionState {
-    model?: string;
-    permissionMode?: string;
-    effort?: string;
-    fallbackModel?: string;
-    runtimeControlValues?: Record<string, string>;
-    state?: 'idle' | 'running' | 'requires_action';
-    contextUsage?: {
-        percentage: number;
-        totalTokens: number;
-        maxTokens: number;
-    };
-}
-export declare function parseClaudePermissionMode(value: unknown): ClaudePermissionMode | null;
-export declare function normalizeClaudeEffortLevel(value: unknown): ClaudeEffortLevel | undefined;
-export declare function buildClaudeInitialSessionState(input: {
-    model?: string;
-    permissionMode?: string;
-    effort?: string;
-    fallbackModel?: string;
-    runtimeControlValues?: Record<string, string>;
-}): ClaudeHostSessionState;
-export interface ClaudeSessionControlTarget {
-    state: ClaudeHostSessionState;
-    controlApplySeq: Map<string, number>;
-    closed: boolean;
-    query: Pick<Query, 'setModel' | 'setPermissionMode' | 'applyFlagSettings'>;
-    writeState: () => void;
-    setRuntimeControlError: (controlId: string, value: string, error: unknown) => void;
-    clearRuntimeControlError: (controlId: string) => void;
-}
-export declare function applyClaudeSessionControl(target: ClaudeSessionControlTarget, ctrl: ClaudeSessionControl): void;
 export interface ClaudePendingFinalDelivery {
     turnKey: string;
     text: string;
@@ -103,15 +60,9 @@ export declare function shouldDeliverClaudeFinal(input: {
     interruptedTurnKeys: ReadonlySet<string>;
 }): boolean;
 export declare function resetClaudeCompletedTurnState(session: ClaudeCompletedTurnState): void;
-export interface ClaudeModelInfoLike {
-    value: string;
-    displayName: string;
-    description?: string;
-}
-export declare function claudeModelInfoToOption(model: ClaudeModelInfoLike): ModelOption;
-export declare function isClaudeCustomModelOption(option: ModelOption | null | undefined): boolean;
-export declare function resolveClaudeModelOptions(input: {
-    discovered: ReadonlyArray<ModelOption>;
+export declare function mergeClaudeModelOptions(input: {
+    previous: ReadonlyArray<ModelOption>;
+    next: ReadonlyArray<ModelOption>;
     selectedModel?: string | null;
 }): ModelOption[];
 export declare function formatClaudeControlError(error: unknown): string;

package/dist/session-state.js

@@ -1,173 +1,4 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { CLAUDE_EFFORT_LEVELS, claudeThinkingToFlagValue, parseClaudeThinkingMode, parseClaudeUltracodeMode, } from './session-defaults.js';
-const CLAUDE_PERMISSION_MODE_VALUES = new Set([
-    'acceptEdits',
-    'auto',
-    'bypassPermissions',
-    'default',
-    'dontAsk',
-    'plan',
-]);
-const CLAUDE_EFFORT_VALUES = new Set(CLAUDE_EFFORT_LEVELS);
-export function parseClaudePermissionMode(value) {
-    return typeof value === 'string' && CLAUDE_PERMISSION_MODE_VALUES.has(value)
-        ? value
-        : null;
-}
-export function normalizeClaudeEffortLevel(value) {
-    return typeof value === 'string' && CLAUDE_EFFORT_VALUES.has(value)
-        ? value
-        : undefined;
-}
-export function buildClaudeInitialSessionState(input) {
-    return {
-        ...(input.model ? { model: input.model } : {}),
-        ...(input.permissionMode ? { permissionMode: input.permissionMode } : {}),
-        ...(input.effort ? { effort: input.effort } : {}),
-        ...(input.fallbackModel ? { fallbackModel: input.fallbackModel } : {}),
-        ...(input.runtimeControlValues ? { runtimeControlValues: input.runtimeControlValues } : {}),
-        state: 'idle',
-    };
-}
-function nextControlApplySeq(target, controlId) {
-    const nextSeq = (target.controlApplySeq.get(controlId) ?? 0) + 1;
-    target.controlApplySeq.set(controlId, nextSeq);
-    return nextSeq;
-}
-function applyOptimisticControl(input) {
-    const seq = nextControlApplySeq(input.target, input.controlId);
-    const applyPromise = (async () => input.apply())();
-    void applyPromise
-        .catch((error) => {
-        if (input.target.closed || input.target.controlApplySeq.get(input.controlId) !== seq) {
-            return;
-        }
-        input.revert();
-        input.target.setRuntimeControlError(input.controlId, input.value, error);
-    });
-}
-function setRuntimeControlValue(state, controlId, value) {
-    state.runtimeControlValues = {
-        ...(state.runtimeControlValues ?? {}),
-        [controlId]: value,
-    };
-}
-export function applyClaudeSessionControl(target, ctrl) {
-    const nextModel = typeof ctrl.model === 'string' && ctrl.model.trim() ? ctrl.model.trim() : null;
-    if (ctrl.model !== undefined && !nextModel) {
-        target.setRuntimeControlError('model', String(ctrl.model), new Error('Unsupported Claude model.'));
-    }
-    else if (nextModel && nextModel !== target.state.model) {
-        const previous = target.state.model;
-        target.state.model = nextModel;
-        target.clearRuntimeControlError('model');
-        applyOptimisticControl({
-            target,
-            controlId: 'model',
-            value: nextModel,
-            apply: () => target.query.setModel(nextModel),
-            revert: () => {
-                if (previous === undefined)
-                    delete target.state.model;
-                else
-                    target.state.model = previous;
-            },
-        });
-    }
-    const nextPermissionMode = parseClaudePermissionMode(ctrl.permissionMode);
-    if (ctrl.permissionMode !== undefined && !nextPermissionMode) {
-        target.setRuntimeControlError('permissionMode', ctrl.permissionMode, new Error(`Unsupported Claude permission mode: ${ctrl.permissionMode}`));
-    }
-    else if (nextPermissionMode && nextPermissionMode !== target.state.permissionMode) {
-        // Claude Code applies permission-mode changes asynchronously. We publish
-        // the requested value immediately so Canon does not show a stale "requested"
-        // state while the SDK catches up, then revert if the current apply fails.
-        const previous = target.state.permissionMode;
-        target.state.permissionMode = nextPermissionMode;
-        target.clearRuntimeControlError('permissionMode');
-        applyOptimisticControl({
-            target,
-            controlId: 'permissionMode',
-            value: nextPermissionMode,
-            apply: () => target.query.setPermissionMode(nextPermissionMode),
-            revert: () => {
-                if (previous === undefined)
-                    delete target.state.permissionMode;
-                else
-                    target.state.permissionMode = previous;
-            },
-        });
-    }
-    const nextEffort = normalizeClaudeEffortLevel(ctrl.effort);
-    if (nextEffort && nextEffort !== target.state.effort) {
-        const previous = target.state.effort;
-        target.state.effort = nextEffort;
-        target.clearRuntimeControlError('effort');
-        applyOptimisticControl({
-            target,
-            controlId: 'effort',
-            value: nextEffort,
-            apply: () => target.query.applyFlagSettings({ effortLevel: nextEffort }),
-            revert: () => {
-                if (previous === undefined)
-                    delete target.state.effort;
-                else
-                    target.state.effort = previous;
-            },
-        });
-    }
-    else if (ctrl.effort !== undefined && !nextEffort) {
-        target.setRuntimeControlError('effort', String(ctrl.effort), new Error('Unsupported Claude thinking level.'));
-    }
-    const runtimeControlValues = ctrl.runtimeControlValues ?? {};
-    if ('thinking' in runtimeControlValues) {
-        const nextThinking = parseClaudeThinkingMode(runtimeControlValues.thinking);
-        if (!nextThinking) {
-            target.setRuntimeControlError('thinking', String(runtimeControlValues.thinking), new Error('Unsupported Claude thinking mode.'));
-        }
-        else if (nextThinking !== target.state.runtimeControlValues?.thinking) {
-            const previous = target.state.runtimeControlValues?.thinking;
-            setRuntimeControlValue(target.state, 'thinking', nextThinking);
-            target.clearRuntimeControlError('thinking');
-            applyOptimisticControl({
-                target,
-                controlId: 'thinking',
-                value: nextThinking,
-                apply: () => target.query.applyFlagSettings({ alwaysThinkingEnabled: claudeThinkingToFlagValue(nextThinking) }),
-                revert: () => {
-                    if (previous === undefined)
-                        delete target.state.runtimeControlValues?.thinking;
-                    else
-                        setRuntimeControlValue(target.state, 'thinking', previous);
-                },
-            });
-        }
-    }
-    if ('ultracode' in runtimeControlValues) {
-        const nextUltracode = parseClaudeUltracodeMode(runtimeControlValues.ultracode);
-        if (!nextUltracode) {
-            target.setRuntimeControlError('ultracode', String(runtimeControlValues.ultracode), new Error('Unsupported Claude ultracode mode.'));
-        }
-        else if (nextUltracode !== target.state.runtimeControlValues?.ultracode) {
-            const previous = target.state.runtimeControlValues?.ultracode;
-            setRuntimeControlValue(target.state, 'ultracode', nextUltracode);
-            target.clearRuntimeControlError('ultracode');
-            applyOptimisticControl({
-                target,
-                controlId: 'ultracode',
-                value: nextUltracode,
-                apply: () => target.query.applyFlagSettings({ ultracode: nextUltracode === 'on' }),
-                revert: () => {
-                    if (previous === undefined)
-                        delete target.state.runtimeControlValues?.ultracode;
-                    else
-                        setRuntimeControlValue(target.state, 'ultracode', previous);
-                },
-            });
-        }
-    }
-    target.writeState();
-}
 export function createClaudeInputEnvelope(input) {
     const sourceMessageId = input.sourceMessageId ?? null;
     const fallbackId = randomUUID();
@@ -215,45 +46,32 @@ export function resetClaudeCompletedTurnState(session) {
     session.toolInProgress = false;
     session.turnState = 'idle';
 }
-function normalizeModelDescription(value) {
-    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
-}
-function displayLabelWithClaudeVersion(input) {
-    const label = input.displayName.trim() || input.value;
-    const description = normalizeModelDescription(input.description);
-    if (!description || label.includes('(') || /\d/.test(label))
-        return label;
-    const [summary] = description.split('·');
-    const versionedLabel = summary?.trim();
-    return versionedLabel
-        && versionedLabel.toLowerCase().startsWith(label.toLowerCase())
-        && /\d/.test(versionedLabel)
-        ? versionedLabel
-        : label;
-}
-export function claudeModelInfoToOption(model) {
-    return {
-        value: model.value,
-        label: displayLabelWithClaudeVersion(model),
-        ...(normalizeModelDescription(model.description) ? { description: normalizeModelDescription(model.description) } : {}),
-    };
-}
-export function isClaudeCustomModelOption(option) {
-    return option?.description?.trim().toLowerCase() === 'custom model';
-}
-export function resolveClaudeModelOptions(input) {
+export function mergeClaudeModelOptions(input) {
     const byValue = new Map();
-    for (const option of input.discovered) {
+    for (const option of input.previous) {
+        byValue.set(option.value, { ...option });
+    }
+    for (const option of input.next) {
         byValue.set(option.value, { ...option });
     }
     if (input.selectedModel && !byValue.has(input.selectedModel)) {
         byValue.set(input.selectedModel, {
             value: input.selectedModel,
             label: input.selectedModel,
-            description: 'Selected for this Canon session but not returned by Claude model discovery.',
+            description: 'Selected for this Canon session but not returned by the latest Claude model probe.',
         });
     }
-    return [...byValue.values()];
+    const nextValues = new Set(input.next.map((option) => option.value));
+    return [...byValue.values()].map((option) => {
+        if (nextValues.has(option.value))
+            return option;
+        return {
+            ...option,
+            description: option.description
+                ? `${option.description} Previously advertised; not returned by the latest Claude model probe.`
+                : 'Previously advertised; not returned by the latest Claude model probe.',
+        };
+    });
 }
 export function formatClaudeControlError(error) {
     if (error instanceof Error && error.message.trim()) {

package/dist/startup-recovery.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Startup recovery for inbound messages missed while the host was offline.
+ *
+ * The host persists a `lastInboundMessageId` cursor per conversation. On
+ * startup we paginate `getMessagesPage` (newest-first pages, older pages via
+ * its `before` message-id parameter) until the cursor is found or a hard
+ * per-conversation bound is hit, then replay everything after the cursor.
+ *
+ * This module is intentionally identical in packages/claude-code-plugin and
+ * packages/codex-plugin — keep both copies in sync (future consolidation
+ * candidate).
+ */
+export declare const STARTUP_RECOVERY_PAGE_SIZE = 25;
+export declare const STARTUP_RECOVERY_MAX_MESSAGES = 500;
+export interface StartupRecoveryMessage {
+    id: string;
+    senderId: string;
+    createdAt?: string;
+}
+export interface StartupRecoveryPage {
+    messages: StartupRecoveryMessage[];
+}
+export type StartupRecoveryMode = 
+/** Cursor found — `messages` is everything strictly after it. */
+'after-cursor'
+/** Cursor present but not found within the bound — `messages` is the bounded recent window. */
+ | 'truncated-window'
+/**
+ * No usable cursor (fresh runtime file, or the cursor message no longer
+ * exists in history) — only the newest inbound message is recovered, since
+ * a full-history replay could fire mass duplicate turns.
+ */
+ | 'latest-only';
+export interface StartupRecoveryResult<TPage extends StartupRecoveryPage> {
+    mode: StartupRecoveryMode;
+    /** Missed inbound messages (own messages excluded), oldest first. */
+    messages: TPage['messages'];
+    /** First page fetched — reusable as hydration context for recovered turns. */
+    newestPage: TPage;
+}
+export declare function collectMissedInboundMessages<TPage extends StartupRecoveryPage>(input: {
+    fetchPage: (before?: string) => Promise<TPage>;
+    cursor: string | null | undefined;
+    agentId: string;
+    maxMessages?: number;
+}): Promise<StartupRecoveryResult<TPage>>;