@canonmsg/claude-code-plugin 0.19.6 → 0.21.0

package/dist/mcp-args.d.ts

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

package/dist/register.js

@@ -9,10 +9,47 @@ import { setDefaultResultOrder } from 'node:dns';
  *
  * On approval, saves the agent to ~/.canon/agents.json under the profile name.
  */
-import { ackRegistrationApproval, clearPendingRegistration, getOrCreatePendingRegistration, registerAndWaitForApproval, updatePendingRegistration, upsertAgentProfile, AGENTS_PATH, } from '@canonmsg/core';
+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 { 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
@@ -62,29 +99,39 @@ export async function main() {
     }
     console.log(`Registering agent "${values.name}" (profile: ${profileName})...`);
     const pending = getOrCreatePendingRegistration(profileName, 'claude-code');
-    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('.');
-        },
-    });
+    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;
+    }
     console.log(''); // newline after dots
     switch (result.status) {
         case 'approved': {
@@ -101,7 +148,7 @@ export async function main() {
                 ...(typeof values['base-url'] === 'string' ? { baseUrl: values['base-url'] } : {}),
             });
             if (result.requestId) {
-                await ackRegistrationApproval(values['base-url'], result.requestId, result.pollToken);
+                await ackRegistrationApprovalWith(transport, values['base-url'], result.requestId, result.pollToken);
             }
             clearPendingRegistration(profileName);
             console.log(`Approved! Agent: ${result.agentName} (${result.agentId})`);
@@ -121,6 +168,7 @@ 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, getActiveProfileLock, markLocalRuntimeStopped, loadProfiles, isProfileLocked, resolveCanonAgent, getActiveProfile, releaseLock, upsertLocalRuntimeEntry, initRTDBAuth, writeSessionState, clearSessionState, renderCanonHostInboundContent, } from '@canonmsg/core';
+import { CanonClient, CanonStream, ApprovalManager, buildLocalRuntimeId, markLocalRuntimeStopped, loadProfiles, isProfileLocked, resolveCanonAgent, releaseLock, upsertLocalRuntimeEntry, initRTDBAuth, renderCanonHostInboundContent, } from '@canonmsg/core';
 import { materializeMessageMedia, sendMediaFileMessage, } from '@canonmsg/agent-sdk';
 import { ApprovalHttpServer } from './approval-server.js';
 import { runCli } from './cli-entry.js';
@@ -34,6 +34,16 @@ 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;
@@ -386,7 +396,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     profile: name,
                     agentName: p.agentName,
                     agentId: p.agentId,
-                    status: getActiveProfile() === name ? 'active (this session)' : lock.locked ? `in use (PID ${lock.pid})` : 'available',
+                    status: activeProfile === name ? 'active (this session)' : lock.locked ? `in use (PID ${lock.pid})` : 'available',
                 };
             });
             if (entries.length === 0) {
@@ -547,6 +557,8 @@ 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);
@@ -577,7 +589,7 @@ async function startChannel() {
         }
     }
     // Initialize RTDB auth for session state reporting
-    initRTDBAuth(client);
+    rtdb = initRTDBAuth(client);
     const runtimeId = buildLocalRuntimeId({
         runtime: 'claude-code',
         profile,
@@ -612,7 +624,7 @@ async function startChannel() {
     // Write initial session state
     const initialState = { cwd: process.cwd(), isActive: true };
     for (const convoId of conversationCache.keys()) {
-        writeSessionState(convoId, agentId, initialState).catch((err) => console.error(`[canon] Failed to write initial state for ${convoId}:`, err));
+        rtdb.writeSessionState(convoId, agentId, initialState).catch((err) => console.error(`[canon] Failed to write initial state for ${convoId}:`, err));
     }
     // Start SSE stream
     stream = new CanonStream({
@@ -665,9 +677,10 @@ export async function main() {
     // Graceful shutdown — release agent lock and clear session state
     const shutdown = () => {
         // Mark all conversations as inactive
-        if (agentContext) {
+        if (agentContext && rtdb) {
+            const scopedRtdb = rtdb;
             for (const convoId of conversationCache.keys()) {
-                clearSessionState(convoId, agentContext.agentId).catch(() => { });
+                scopedRtdb.clearSessionState(convoId, agentContext.agentId).catch(() => { });
             }
         }
         approvalManager?.dispose();
@@ -675,15 +688,14 @@ export async function main() {
         stream?.stop();
         const runtimeId = buildLocalRuntimeId({
             runtime: 'claude-code',
-            profile: getActiveProfile(),
+            profile: activeProfile,
             cwd: process.cwd(),
             launchCommand: ['canon-channel-server'],
         });
         markLocalRuntimeStopped(runtimeId);
-        const ap = getActiveProfile();
-        if (ap)
-            releaseLock(ap);
-        getActiveProfileLock()?.release();
+        if (activeProfile)
+            releaseLock(activeProfile);
+        activeLockHandle?.release();
         process.exit(0);
     };
     process.on('SIGINT', shutdown);

package/dist/session-defaults.d.ts

@@ -0,0 +1,34 @@
+import type { AgentDefinition, EffortLevel, ThinkingConfig } from '@anthropic-ai/claude-agent-sdk';
+export type ClaudeThinkingMode = 'adaptive' | 'off';
+export type ClaudeUltracodeMode = 'on' | 'off';
+export type ClaudeEffortLevel = Extract<EffortLevel, 'low' | 'medium' | 'high' | 'xhigh' | 'max'>;
+export interface ClaudeSessionDefaults {
+    model?: string;
+    effort?: ClaudeEffortLevel;
+    thinking?: ClaudeThinkingMode;
+    ultracode?: ClaudeUltracodeMode;
+    fallbackModel?: string;
+    agentProgressSummaries?: boolean;
+    agents?: Record<string, AgentDefinition>;
+}
+export interface ClaudeSessionControlValues {
+    thinking?: ClaudeThinkingMode;
+    ultracode?: ClaudeUltracodeMode;
+}
+export interface ClaudeEffectiveSessionSettings extends ClaudeSessionDefaults {
+    runtimeControlValues: Record<string, string>;
+}
+export declare function parseClaudeThinkingMode(value: unknown): ClaudeThinkingMode | undefined;
+export declare function parseClaudeUltracodeMode(value: unknown): ClaudeUltracodeMode | undefined;
+export declare function parseClaudeSessionDefaults(raw: unknown): ClaudeSessionDefaults;
+export declare function parseClaudeSessionControlValues(values: Record<string, string> | null | undefined): ClaudeSessionControlValues;
+export declare function claudeThinkingToConfig(mode: ClaudeThinkingMode | undefined): ThinkingConfig | undefined;
+export declare function claudeThinkingToFlagValue(mode: ClaudeThinkingMode): boolean;
+export declare function resolveEffectiveSessionSettings(input: {
+    profileDefaults?: ClaudeSessionDefaults;
+    sessionConfig?: {
+        model?: string;
+        effort?: ClaudeEffortLevel;
+        runtimeControlValues?: Record<string, string>;
+    } | null;
+}): ClaudeEffectiveSessionSettings;

package/dist/session-defaults.js

@@ -0,0 +1,123 @@
+const CLAUDE_EFFORT_VALUES = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
+function optionalString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function optionalBoolean(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
+export function parseClaudeThinkingMode(value) {
+    if (value === false || value === 'off' || value === 'disabled')
+        return 'off';
+    if (value === true || value === 'on' || value === 'adaptive' || value === 'enabled')
+        return 'adaptive';
+    return undefined;
+}
+export function parseClaudeUltracodeMode(value) {
+    if (value === true || value === 'on' || value === 'enabled')
+        return 'on';
+    if (value === false || value === 'off' || value === 'disabled')
+        return 'off';
+    return undefined;
+}
+function parseEffort(value) {
+    const normalized = optionalString(value);
+    if (!normalized)
+        return undefined;
+    return CLAUDE_EFFORT_VALUES.has(normalized)
+        ? normalized
+        : undefined;
+}
+function parseStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const out = value
+        .map((entry) => optionalString(entry))
+        .filter((entry) => Boolean(entry));
+    return out.length > 0 ? out : undefined;
+}
+function parseAgentDefinition(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const data = value;
+    const description = optionalString(data.description);
+    const prompt = optionalString(data.prompt);
+    if (!description || !prompt)
+        return null;
+    return {
+        description,
+        prompt,
+        ...(parseStringArray(data.tools) ? { tools: parseStringArray(data.tools) } : {}),
+        ...(parseStringArray(data.disallowedTools) ? { disallowedTools: parseStringArray(data.disallowedTools) } : {}),
+        ...(optionalString(data.model) ? { model: optionalString(data.model) } : {}),
+        ...(parseStringArray(data.skills) ? { skills: parseStringArray(data.skills) } : {}),
+        ...(typeof data.maxTurns === 'number' && Number.isFinite(data.maxTurns) && data.maxTurns > 0
+            ? { maxTurns: Math.floor(data.maxTurns) }
+            : {}),
+        ...(typeof data.background === 'boolean' ? { background: data.background } : {}),
+        ...(parseEffort(data.effort) ? { effort: parseEffort(data.effort) } : {}),
+    };
+}
+function parseAgents(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const out = {};
+    for (const [rawName, rawAgent] of Object.entries(value)) {
+        const name = rawName.trim();
+        if (!name)
+            continue;
+        const agent = parseAgentDefinition(rawAgent);
+        if (agent)
+            out[name] = agent;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+export function parseClaudeSessionDefaults(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return {};
+    const data = raw;
+    return {
+        ...(optionalString(data.model) ? { model: optionalString(data.model) } : {}),
+        ...(parseEffort(data.effort) ? { effort: parseEffort(data.effort) } : {}),
+        ...(parseClaudeThinkingMode(data.thinking) ? { thinking: parseClaudeThinkingMode(data.thinking) } : {}),
+        ...(parseClaudeUltracodeMode(data.ultracode) ? { ultracode: parseClaudeUltracodeMode(data.ultracode) } : {}),
+        ...(optionalString(data.fallbackModel) ? { fallbackModel: optionalString(data.fallbackModel) } : {}),
+        ...(optionalBoolean(data.agentProgressSummaries) !== undefined
+            ? { agentProgressSummaries: optionalBoolean(data.agentProgressSummaries) }
+            : {}),
+        ...(parseAgents(data.agents) ? { agents: parseAgents(data.agents) } : {}),
+    };
+}
+export function parseClaudeSessionControlValues(values) {
+    return {
+        ...(parseClaudeThinkingMode(values?.thinking) ? { thinking: parseClaudeThinkingMode(values?.thinking) } : {}),
+        ...(parseClaudeUltracodeMode(values?.ultracode) ? { ultracode: parseClaudeUltracodeMode(values?.ultracode) } : {}),
+    };
+}
+export function claudeThinkingToConfig(mode) {
+    if (mode === 'adaptive')
+        return { type: 'adaptive' };
+    if (mode === 'off')
+        return { type: 'disabled' };
+    return undefined;
+}
+export function claudeThinkingToFlagValue(mode) {
+    return mode !== 'off';
+}
+export function resolveEffectiveSessionSettings(input) {
+    const controlValues = parseClaudeSessionControlValues(input.sessionConfig?.runtimeControlValues);
+    const runtimeControlValues = {
+        ...(input.profileDefaults?.thinking ? { thinking: input.profileDefaults.thinking } : {}),
+        ...(input.profileDefaults?.ultracode ? { ultracode: input.profileDefaults.ultracode } : {}),
+        ...(input.sessionConfig?.runtimeControlValues ?? {}),
+        ...(controlValues.thinking ? { thinking: controlValues.thinking } : {}),
+        ...(controlValues.ultracode ? { ultracode: controlValues.ultracode } : {}),
+    };
+    return {
+        ...(input.profileDefaults ?? {}),
+        ...(input.sessionConfig?.model ? { model: input.sessionConfig.model } : {}),
+        ...(input.sessionConfig?.effort ? { effort: input.sessionConfig.effort } : {}),
+        ...(controlValues.thinking ? { thinking: controlValues.thinking } : {}),
+        ...(controlValues.ultracode ? { ultracode: controlValues.ultracode } : {}),
+        runtimeControlValues,
+    };
+}

package/dist/session-state.d.ts

@@ -1,6 +1,6 @@
 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';
+import type { DeliveryIntent, ModelOption, TurnLifecycleState } from '@canonmsg/core/contract';
+import type { TurnArtifactSnapshot } from '@canonmsg/agent-host';
 export type ClaudeInputKind = 'seed' | 'canon';
 export type ClaudeArtifactRoutingMode = 'workspace-generated' | 'disabled';
 export interface ClaudeInputEnvelope {

package/dist/subagent-activity.d.ts

@@ -0,0 +1,11 @@
+import type { SDKTaskNotificationMessage, SDKTaskProgressMessage, SDKTaskStartedMessage, SDKTaskUpdatedMessage } from '@anthropic-ai/claude-agent-sdk';
+type ClaudeTaskMessage = SDKTaskNotificationMessage | SDKTaskProgressMessage | SDKTaskStartedMessage | SDKTaskUpdatedMessage;
+export interface ClaudeSubagentActivityBlock {
+    id: string;
+    kind: 'status';
+    status: 'running' | 'completed' | 'failed';
+    title: string;
+    text?: string;
+}
+export declare function mapClaudeSubagentActivity(message: ClaudeTaskMessage): ClaudeSubagentActivityBlock | null;
+export {};

package/dist/subagent-activity.js

@@ -0,0 +1,51 @@
+function titleForMessage(message) {
+    const subtype = message.subtype;
+    if (subtype === 'task_started') {
+        return message.subagent_type
+            ? `Subagent started: ${message.subagent_type}`
+            : 'Subagent started';
+    }
+    if (subtype === 'task_progress') {
+        return message.subagent_type
+            ? `Subagent progress: ${message.subagent_type}`
+            : 'Subagent progress';
+    }
+    if (subtype === 'task_updated')
+        return 'Subagent updated';
+    return `Subagent ${message.status}`;
+}
+function textForMessage(message) {
+    if (message.subtype === 'task_started')
+        return message.description;
+    if (message.subtype === 'task_progress')
+        return message.summary ?? message.description;
+    if (message.subtype === 'task_updated')
+        return message.patch.description ?? message.patch.error;
+    return message.summary;
+}
+function statusForMessage(message) {
+    if (message.subtype === 'task_notification') {
+        if (message.status === 'completed')
+            return 'completed';
+        return 'failed';
+    }
+    if (message.subtype === 'task_updated') {
+        if (message.patch.status === 'completed')
+            return 'completed';
+        if (message.patch.status === 'failed' || message.patch.status === 'killed')
+            return 'failed';
+    }
+    return 'running';
+}
+export function mapClaudeSubagentActivity(message) {
+    if ('skip_transcript' in message && message.skip_transcript)
+        return null;
+    const text = textForMessage(message);
+    return {
+        id: `task:${message.task_id}`,
+        kind: 'status',
+        status: statusForMessage(message),
+        title: titleForMessage(message),
+        ...(text ? { text } : {}),
+    };
+}

package/dist/tool-policy.d.ts

@@ -1,4 +1,5 @@
-import type { ApprovalManager, ApprovalRequestCategory, ApprovalRequestDetail, ApprovalRisk, CanonUnifiedDiff } from '@canonmsg/core';
+import type { ApprovalRequestCategory, ApprovalRequestDetail, ApprovalRisk, CanonUnifiedDiff } from '@canonmsg/core/contract';
+import type { ApprovalManager } from '@canonmsg/core/host';
 export type ClaudeToolPolicyDecision = {
     behavior: 'allow';
 } | {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.19.6",
+  "version": "0.21.0",
   "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/index.js",
@@ -23,17 +23,19 @@
     ".claude-plugin"
   ],
   "scripts": {
-    "prepare:workspace-deps": "node ../../scripts/run-workspace-prep.mjs ../core ../agent-sdk ../coding-agent-host",
+    "prepare:workspace-deps": "node ../../scripts/run-workspace-prep.mjs ../../packages/core ../../packages/agent-sdk ../../packages/framework ../../packages/bridge ../../packages/agent-host",
     "build": "npm run prepare:workspace-deps && node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
     "dev": "npm run prepare:workspace-deps && tsc --watch",
     "prepack": "npm run build",
     "test": "vitest run"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.141",
-    "@canonmsg/agent-sdk": "^3.4.2",
-    "@canonmsg/coding-agent-host": "^0.2.2",
-    "@canonmsg/core": "^3.0.0",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.200",
+    "@canonmsg/agent-host": "^0.4.0",
+    "@canonmsg/agent-sdk": "^3.4.4",
+    "@canonmsg/bridge": "^0.2.0",
+    "@canonmsg/core": "^3.2.0",
+    "@canonmsg/framework": "^0.2.0",
     "@modelcontextprotocol/sdk": "^1.29.0"
   },
   "engines": {
@@ -50,9 +52,9 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/HeyBobChan/canon",
-    "directory": "packages/claude-code-plugin"
+    "directory": "adapters/claude-code-plugin"
   },
-  "homepage": "https://github.com/HeyBobChan/canon/tree/main/packages/claude-code-plugin",
+  "homepage": "https://github.com/HeyBobChan/canon/tree/main/adapters/claude-code-plugin",
   "publishConfig": {
     "access": "public"
   },

package/dist/inbound-policy.d.ts

@@ -1,22 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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/startup-recovery.d.ts

@@ -1,46 +0,0 @@
-/**
- * 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>>;