@canonmsg/claude-code-plugin 0.29.0 → 0.29.2

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "Canon",
   "description": "Connect Claude Code to Canon — messaging where AI agents are first-class citizens",
-  "version": "0.29.0",
+  "version": "0.29.2",
   "channels": [
     {
       "server": "canon-channel",

package/README.md

@@ -4,13 +4,14 @@ Connect Claude Code to [Canon](https://github.com/HeyBobChan/canon) — a messag
 
 ## Quick start
 
-The package includes a compatible Claude Code runtime. If `claude` is installed on `PATH`, or selected with `CANON_CLAUDE_CLI_PATH`, use Claude Code 2.1.220 or newer — the model picker lists whatever the CLI reports, so an older binary hides newer model families. A `PATH` install below that minimum is skipped in favour of the bundled runtime; a `CANON_CLAUDE_CLI_PATH` below it is a hard error.
+The package includes a compatible Claude Code runtime. If `claude` is installed on `PATH`, or selected with `CANON_CLAUDE_CLI_PATH`, use Claude Code 2.1.220 or newer — the model picker lists whatever the CLI reports, so an older binary hides newer model families. Either source below that minimum is logged and skipped in favour of the bundled runtime, so a stale install costs model options rather than taking the host down.
 
 ```bash
 # Install
 npm install -g @canonmsg/claude-code-plugin
 
 # Register (approve in Canon app when prompted)
+export CANON_ENVIRONMENT_ID=canon-prod-v1
 canon-register --name "My Claude" --description "My Claude Code agent" --phone "+15551234567"
 
 # Run
@@ -38,6 +39,10 @@ Public docs: <https://canonmail.com/agents/integrations>. Coding-host concepts:
 
 - **Two-way messaging** — Messages from Canon flow to Claude Code and back
 - **Session controls** — Canon renders setup and live controls from the runtime descriptor Claude publishes
+- **Blocking approvals** — Tool permission requests become approval cards in Canon and hold the turn until answered
+- **Questions from Claude** — `AskUserQuestion` dialogs render as answerable cards in the conversation
+- **Runtime commands** — `/status`, `/mcp`, `/plugins`, `/model`, `/permission`, `/effort`, `/ultracode`, `/plan`, plus the CLI's own slash commands passed through to the runtime
+- **Canon verb tools** — Claude can act on Canon itself through an in-process verb MCP server mounted into every host session
 - **Live preview** — See Claude's current live preview/status in the app
 - **Interrupt** — Stop Claude mid-response from the app
 - **Context meter** — See context window usage in the app
@@ -70,25 +75,56 @@ Current Canon truth for Claude host mode:
 ## Multiple agents
 
 ```bash
+export CANON_ENVIRONMENT_ID=canon-prod-v1
 canon-register --name "Frontend" --description "React work" --phone "+1..." --profile frontend
 CANON_AGENT=frontend canon-claude --cwd ~/projects/frontend
 ```
 
+With more than one registered profile, `CANON_AGENT` is required — the host refuses to guess and lists the available profiles instead.
+
 ## Channel mode (alternative)
 
-For a lighter integration without session controls, run Canon as a channel plugin inside your own Claude Code session. The `canon-channel-server` binary (installed by this package) is an MCP stdio server that Claude Code launches.
+For a lighter integration without session controls, run Canon as a channel inside your own Claude Code session. The `canon-channel-server` binary (installed by this package) is an MCP stdio server that Claude Code launches as a channel.
+
+Add it to the project's `.mcp.json` (or `~/.mcp.json` for global):
 
-Register the channel server with Claude Code's MCP config and provide your Canon API key via the `CANON_API_KEY` environment variable:
+```json
+{
+  "mcpServers": {
+    "canon-channel": {
+      "command": "canon-channel-server"
+    }
+  }
+}
+```
+
+Then start Claude Code with the channel loaded:
 
 ```bash
-# Register once per Claude Code project
-claude mcp add canon-channel canon-channel-server
+CANON_API_KEY=agk_live_... CANON_ENVIRONMENT_ID=canon-prod-v1 \
+  claude --dangerously-load-development-channels server:canon-channel
+```
 
-# Then start Claude Code with your Canon key in the environment
-CANON_API_KEY=agk_live_... CANON_ENVIRONMENT_ID=canon-prod-v1 claude
+The launch flag is what activates channel mode; plain `claude` treats the binary as an ordinary MCP server and never opens the channel. Inbound Canon messages then arrive as `<channel>` tags and Claude answers with the `reply` tool. Canon shows a read-only session status instead of host-mode controls, and `canon-necromance` lists the session as non-revivable.
+
+If you registered a profile with `canon-register`, pin it instead of passing the key — the stored profile carries its own environment binding:
+
+```json
+{
+  "mcpServers": {
+    "canon-channel": {
+      "command": "canon-channel-server",
+      "env": { "CANON_AGENT": "my-agent" }
+    }
+  }
+}
 ```
 
-Channel mode forwards messages between Canon conversations and the embedded Claude Code session without managing session lifecycle. It is shown as non-revivable by `canon-necromance`. Use `canon-claude` host mode when you want phone-controlled runtime sessions with setup and live controls.
+`CANON_PLUGIN_API_KEY` is accepted wherever `CANON_API_KEY` is; the bundled Claude Code plugin manifest sets it from user config. `CANON_ENVIRONMENT_ID` is still required with either variable.
+
+`canon-setup` installs the bundled `/canon-register` and `/canon-configure` skills into `~/.claude/skills` and prints this MCP configuration.
+
+Use `canon-claude` host mode when you want phone-controlled runtime sessions with setup and live controls.
 
 ## Development
 

package/dist/approval-server.d.ts

@@ -29,5 +29,4 @@ export declare class ApprovalHttpServer {
     private hasValidToken;
     private handleApproval;
     private sendHookResponse;
-    private classifyRisk;
 }

package/dist/approval-server.js

@@ -131,8 +131,9 @@ export class ApprovalHttpServer {
         }
         const toolName = payload.tool_name ?? 'Unknown';
         const toolInput = payload.tool_input ?? {};
-        // Determine risk level
-        const riskLevel = this.classifyRisk(toolName, toolInput);
+        // Single source of truth for risk, shared with host mode (tool-policy.ts).
+        const risk = classifyClaudeApprovalRisk(toolName, toolInput);
+        const riskLevel = risk === 'destructive' ? 'destructive' : 'normal';
         const isOwnerTurn = this.getIsOwnerTurn();
         // Find the conversation to send the approval to.
         const conversationId = this.getConversationId();
@@ -154,7 +155,7 @@ export class ApprovalHttpServer {
         try {
             const result = await this.manager.requestApproval(conversationId, toolName, toolInput, {
                 riskLevel,
-                risk: classifyClaudeApprovalRisk(toolName, toolInput),
+                risk,
                 category: classifyClaudeApprovalCategory(toolName),
                 native: {
                     runtime: 'claude-code',
@@ -182,19 +183,4 @@ export class ApprovalHttpServer {
             },
         }));
     }
-    classifyRisk(toolName, toolInput) {
-        if (toolName !== 'Bash')
-            return 'normal';
-        const cmd = typeof toolInput.command === 'string' ? toolInput.command : '';
-        const destructivePatterns = [
-            /\brm\s+(-rf?|--force)/,
-            /\bgit\s+push\s+--force/,
-            /\bgit\s+reset\s+--hard/,
-            /\bdrop\s+(table|database)/i,
-            /\bformat\b/,
-        ];
-        return destructivePatterns.some((p) => p.test(cmd))
-            ? 'destructive'
-            : 'normal';
-    }
 }

package/dist/host.js

@@ -27,16 +27,14 @@ import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { query, } from '@anthropic-ai/claude-agent-sdk';
 import { isAnthropicImageAttachment, materializeMessageMedia, materializeReplyContextMedia, sendMediaFileMessage, toAnthropicImageBlock, } from '@canonmsg/agent-sdk';
-import { captureTurnArtifactSnapshot, collectTurnArtifacts, IDLE_TIMEOUT_MS, } from '@canonmsg/coding-agent-host';
-import { CLAUDE_EFFORT_OPTIONS, CLAUDE_PERMISSION_MODE_OPTIONS, RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildCanonInboundFrameV1, buildCanonTurnContextV2, buildConfiguredWorkspaceOptionsWithRoots, buildConversationEnvironmentKey, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, normalizeRuntimeCommandDescriptors, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, buildBoundedTurnTrail, createConversationMetadataLoader, createTurnOutputController, createRuntimeStatePublisher, createTypingStatusPublisher, EXECUTION_ENVIRONMENT_MODES, CanonClient, CanonStream, ControlChannelPoller, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, HOST_ADMISSION_ACTIONS_DISABLED, ApprovalManager, RuntimeRequestManager, ExecutionEnvironmentError, FINAL_MESSAGE_HANDOFF_MS, buildLocalRuntimeId, getActiveProfileLock, heartbeatLocalRuntimeEntry, normalizeTurnMetadata, prepareConversationEnvironment, readLocalRuntimeEntry, resolveCanonAgent, verifyResolvedAgentEnvironment, initRTDBAuth, isChunkedSendMessageError, sendMessageWithRetry, sendMessageWithRetryChunked, loadHostSessionConfig, loadRuntimeSessionState, markLocalRuntimeStopped, releaseConversationEnvironment, saveRuntimeSessionState, clearRuntimeSessionState, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, renderCodingHostInboundPrompt, resolveHostWorkspaceCwd, shouldTriggerAgentTurn, upsertLocalRuntimeEntry, } from '@canonmsg/core';
-import { decideAutoReply, } from './inbound-policy.js';
-import { runCli } from './cli-entry.js';
+import { captureTurnArtifactSnapshot, collectTurnArtifacts, IDLE_TIMEOUT_MS, collectMissedInboundMessages, createReconnectRecoveryGate, STARTUP_RECOVERY_MAX_MESSAGES, STARTUP_RECOVERY_PAGE_SIZE, } from '@canonmsg/coding-agent-host';
+import { EFFORT_OPTIONS, CLAUDE_PERMISSION_MODE_OPTIONS, RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildCanonInboundFrameV1, buildCanonTurnContextV2, buildConfiguredWorkspaceOptionsWithRoots, buildConversationEnvironmentKey, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, normalizeRuntimeCommandDescriptors, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, buildBoundedTurnTrail, createConversationMetadataLoader, createTurnOutputController, createRuntimeStatePublisher, createTypingStatusPublisher, EXECUTION_ENVIRONMENT_MODES, CanonClient, CanonStream, ControlChannelPoller, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, HOST_ADMISSION_ACTIONS_DISABLED, ApprovalManager, RuntimeRequestManager, ExecutionEnvironmentError, FINAL_MESSAGE_HANDOFF_MS, buildLocalRuntimeId, getActiveProfileLock, heartbeatLocalRuntimeEntry, normalizeTurnMetadata, prepareConversationEnvironment, resolveCanonAgent, verifyResolvedAgentEnvironment, decideAutoReply, initRTDBAuth, isChunkedSendMessageError, sendMessageWithRetry, sendMessageWithRetryChunked, loadHostSessionConfig, loadRuntimeSessionState, markLocalRuntimeStopped, releaseConversationEnvironment, saveRuntimeSessionState, clearRuntimeSessionState, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, renderCodingHostInboundPrompt, resolveHostWorkspaceCwd, shouldTriggerAgentTurn, upsertLocalRuntimeEntry, } from '@canonmsg/core';
+import { runCli } from '@canonmsg/core';
 import { CANON_VERB_MCP_SERVER_NAME, createCanonVerbMcpServer } from '@canonmsg/agent-tools';
 import { synthesizeClaudeApprovalDiff } from './approval-diff.js';
 import { decideClaudeToolPermissionForMode, parseAllowedNonOwnerClaudeTools, } from './tool-policy.js';
 import { applyClaudeSessionControl, boundClaudeFinalMetadata, buildClaudeFinalChunkingOptions, buildClaudeFinalMessageId, buildClaudeFinalTurnMetadata, buildClaudePendingFinalDelivery, buildClaudeTurnFailureNotice, buildTruncatedFinalText, buildUndeliverableFinalNotice, canDrainClaudeQueuedInput, claudeFinalWillChunk, classifyFinalDeliveryFailure, claudeInputOwnsTurnSlot, createClaudeTurnActivityState, decideClaudeControlSignalAction, decideClaudeInboundDispatch, dispatchClaudeInput, isClaudeTurnSlotReserved, readClaudeFinalDeliveryResume, releaseClaudeTurnSlot, runClaudeExhaustedFinalDelivery, shouldApplyClaudeEchoedSessionState, shouldReleaseClaudeTurnSlot, isClaudeMainTurnMessage, openClaudeTurn, planClaudeAssistantTrail, planClaudeToolCallStart, planClaudeToolProgress, planClaudeToolResults, prepareTurnTrailForDelivery, rememberDispatchedClaudeInput, resetClaudeTurnActivityState, shouldOpenClaudeTurnOnRunning, isOpenClaudeTurnState, takeClaudeResultOwner, takeClaudeToolBlockIdByIndex, claudeModelInfoToOption, claudeOriginForCanonSender, composeClaudeFinalText, describeUndeliveredClaudeFinal, confirmClaudeInterrupt, createClaudeInputEnvelope, deriveClaudeSupplementalModelProbes, formatClaudeCliVersion, formatClaudeControlError, isClaudeCustomModelOption, isSupportedClaudeCliVersion, mergeClaudeDiscoveredModelOptions, parseClaudeCliVersion, resolveClaudeTurnResponseRouting, resolveClaudeModelOptions, resetClaudeCompletedTurnState, shouldDeliverClaudeFinal, MINIMUM_CLAUDE_CLI_VERSION, } from './session-state.js';
 import { CLAUDE_SUPPORTED_DIALOG_KINDS, buildClaudeAskUserPermissionDenied, buildClaudeAskUserPermissionResult, createClaudeUserDialogCoordinator, parseClaudeAskUserDialog, parseClaudeAskUserToolInput, resolveClaudeUserDialogRequestId, } from './user-dialog.js';
-import { collectMissedInboundMessages, createReconnectRecoveryGate, STARTUP_RECOVERY_MAX_MESSAGES, STARTUP_RECOVERY_PAGE_SIZE, } from './startup-recovery.js';
 function parseRuntimeVisibilityPreset(value) {
     return value === 'normal' || value === 'minimal' || value === 'full' ? value : undefined;
 }
@@ -194,7 +192,7 @@ function buildClaudeRuntimeDescriptor(input) {
                     label: 'Level',
                     kind: 'enum',
                     required: true,
-                    choices: [...CLAUDE_EFFORT_OPTIONS],
+                    choices: [...EFFORT_OPTIONS],
                 }],
             dispatch: {
                 kind: 'control',
@@ -237,7 +235,7 @@ function buildClaudeRuntimeDescriptor(input) {
         executionModes: input.executionModes,
         permissionModes: CLAUDE_PERMISSION_MODE_OPTIONS,
         defaultPermissionMode: 'default',
-        effortOptions: [...CLAUDE_EFFORT_OPTIONS],
+        effortOptions: [...EFFORT_OPTIONS],
         extraRuntimeControls: [{
                 id: 'ultracode',
                 label: 'Ultracode',
@@ -272,7 +270,7 @@ function buildClaudeRuntimeDescriptor(input) {
         commands,
     });
 }
-const CLAUDE_EFFORT_VALUES = new Set(CLAUDE_EFFORT_OPTIONS.map((option) => option.value));
+const CLAUDE_EFFORT_VALUES = new Set(EFFORT_OPTIONS.map((option) => option.value));
 function parseClaudePermissionMode(value) {
     if (value === 'acceptEdits'
         || value === 'auto'
@@ -376,13 +374,14 @@ function acceptClaudeCli(source, cliPath) {
 function toModelOptions(models) {
     return models.map(claudeModelInfoToOption);
 }
-async function publishAgentRuntime(agentId, runtime) {
-    await publishHostAgentRuntime(agentId, 'claude-code', runtime);
+async function publishAgentRuntime(agentId, runtime, rtdb) {
+    await publishHostAgentRuntime(agentId, 'claude-code', runtime, rtdb);
 }
-async function loadSessionConfig(conversationId, agentId) {
+async function loadSessionConfig(conversationId, agentId, rtdb) {
     const config = await loadHostSessionConfig({
         conversationId,
         agentId,
+        rtdb,
         extraStringFields: ['permissionMode', 'effort'],
     });
     return {
@@ -1482,13 +1481,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             const deliveredMessageIds = chunkedFailure
                 ? chunkedFailure.deliveredMessageIds
                 : resume.deliveredMessageIds;
-            const failure = classifyFinalDeliveryFailure(cause, { chunked: willChunk });
-            if (failure === 'already-delivered') {
-                // The server's idempotency guard says this final is already durable.
-                markFinalTurnDelivered(deliverTurn);
-                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Final reply was already delivered under this id`);
-                return true;
-            }
+            const failure = classifyFinalDeliveryFailure(cause);
             if (failure === 'permanent') {
                 // Re-sending is pointless — the same request fails the same way. Surface
                 // what can be surfaced and finish the turn instead of burning the retry
@@ -2089,6 +2082,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                             if (!shouldApplyClaudeEchoedSessionState({
                                 echoed: state,
                                 dispatching: session.dispatchingInput !== null,
+                                active: session.activeInput !== null,
                                 hasPendingFinalDelivery: Boolean(session.pendingFinalDelivery),
                             })) {
                                 console.error(`[canon-host] [${conversationId.slice(0, 8)}] `
@@ -2420,6 +2414,7 @@ export async function main() {
         agentId,
         clientType: 'claude-code',
         hostMode: true,
+        rtdb,
     });
     let streamConnected = false;
     const hostAvailableExecutionModes = [
@@ -2460,6 +2455,7 @@ export async function main() {
         await publishHostSessionSnapshots({
             conversationIds,
             agentId,
+            rtdb,
             clientType: 'claude-code',
             runtime: runtimeDescriptor,
             workspaceOptions,
@@ -2504,7 +2500,7 @@ export async function main() {
             console.error('[canon-host] Failed to refresh Claude runtime metadata:', error);
             return runtimeMetadata;
         });
-        await publishAgentRuntime(agentId, runtimeDescriptor).catch((error) => {
+        await publishAgentRuntime(agentId, runtimeDescriptor, rtdb).catch((error) => {
             console.error('[canon-host] Failed to publish agent runtime:', error);
         });
         await publishSessionSnapshots(Array.from(knownConversationIds));
@@ -2865,7 +2861,7 @@ export async function main() {
             evictOldestIdle();
         }
         const creation = (async () => {
-            const config = await loadSessionConfig(conversationId, agentId);
+            const config = await loadSessionConfig(conversationId, agentId, rtdb);
             const sessionExecutionMode = resolveSessionExecutionMode(config);
             const workspaceCwd = resolveWorkspaceCwd(config);
             const environment = prepareConversationEnvironment({
@@ -3119,40 +3115,21 @@ export async function main() {
         }
         return consumed;
     }
-    function persistedConversationCursors(conversationId) {
-        const canonicalCursor = loadRuntimeSessionState(runtimeId, {
+    function persistedConversationCursor(conversationId) {
+        return loadRuntimeSessionState(runtimeId, {
             conversationId,
             baseCwd: workingDir,
             workspaceId: CLAUDE_RECOVERY_CURSOR_WORKSPACE_ID,
         })?.lastInboundMessageId ?? null;
-        if (canonicalCursor)
-            return { canonicalCursor, legacyCursors: [] };
-        const legacyCursors = Object.values(readLocalRuntimeEntry(runtimeId)?.sessions ?? {})
-            .filter((state) => state.conversationId === conversationId)
-            .map((state) => state.lastInboundMessageId)
-            .filter((messageId) => Boolean(messageId));
-        return { canonicalCursor: null, legacyCursors: [...new Set(legacyCursors)] };
     }
     async function performMissedInboundRecovery() {
         for (const conversationId of knownConversationIds) {
             try {
-                const cursors = persistedConversationCursors(conversationId);
                 const recovered = await collectMissedInboundMessages({
                     fetchPage: (before) => client.getMessagesPage(conversationId, STARTUP_RECOVERY_PAGE_SIZE, before),
-                    cursor: cursors.canonicalCursor,
-                    cursorCandidates: cursors.legacyCursors,
+                    cursor: persistedConversationCursor(conversationId),
                     agentId,
                 });
-                if (!cursors.canonicalCursor
-                    && recovered.cursor
-                    && recovered.messages.length === 0) {
-                    saveRuntimeSessionState(runtimeId, {
-                        conversationId,
-                        baseCwd: workingDir,
-                        workspaceId: CLAUDE_RECOVERY_CURSOR_WORKSPACE_ID,
-                        lastInboundMessageId: recovered.cursor,
-                    });
-                }
                 if (recovered.mode === 'truncated-window') {
                     console.error(`[canon-host] [${conversationId.slice(0, 8)}] Recovery cursor was not found within ${STARTUP_RECOVERY_MAX_MESSAGES} messages; replaying the bounded recent window`);
                 }

package/dist/register.d.ts

@@ -1,2 +1,11 @@
 #!/usr/bin/env node
+/**
+ * CLI script for Canon agent registration.
+ * Invoked by the /canon-register skill.
+ *
+ * Usage:
+ *   node register.js --name "My Agent" --description "What it does" --phone "+15551234567" [--profile "my-agent"]
+ *
+ * On approval, saves the agent to ~/.canon/agents.json under the profile name.
+ */
 export declare function main(): Promise<void>;

package/dist/register.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-import { setDefaultResultOrder } from 'node:dns';
 /**
  * CLI script for Canon agent registration.
  * Invoked by the /canon-register skill.
@@ -9,9 +8,7 @@ import { setDefaultResultOrder } from 'node:dns';
  *
  * On approval, saves the agent to ~/.canon/agents.json under the profile name.
  */
-import { ackRegistrationApproval, clearPendingRegistration, getOrCreatePendingRegistration, loadProfiles, registerAndWaitForApproval, resolveCanonRuntimeConnection, updatePendingRegistration, upsertAgentProfile, verifyCanonRuntimeConnection, } from '@canonmsg/core';
-import { parseArgs } from 'node:util';
-import { runCli } from './cli-entry.js';
+import { registerRegistrationCli, runRegistrationCli, } from '@canonmsg/core';
 const HELP = `canon-register — register or reconnect a Claude Code agent in Canon
 
 USAGE
@@ -37,114 +34,17 @@ EXAMPLES
   canon-register --name "Frontend" --description "React work" --phone "+15551234567" --profile frontend
 
 After approval, start it with CANON_AGENT=<profile> canon-claude --cwd /path/to/project.`;
+const OPTIONS = {
+    moduleUrl: import.meta.url,
+    clientType: 'claude-code',
+    cliName: 'canon-register',
+    hostBinName: 'canon-claude',
+    developerInfo: 'Claude Code plugin',
+    registeringLabel: 'agent',
+    usage: 'Usage: node register.js --name "Agent Name" --description "Description" --phone "+15551234567" [--profile "my-agent"]',
+    help: HELP,
+};
 export async function main() {
-    setDefaultResultOrder('ipv4first');
-    const { values } = parseArgs({
-        options: {
-            name: { type: 'string' },
-            description: { type: 'string' },
-            phone: { type: 'string' },
-            profile: { type: 'string' },
-            environment: { type: 'string' },
-            'base-url': { type: 'string' },
-            'stream-url': { type: 'string' },
-            'rtdb-url': { type: 'string' },
-            'firebase-api-key': { type: 'string' },
-        },
-        strict: true,
-    });
-    if (!values.name || !values.description || !values.phone) {
-        console.error('Usage: node register.js --name "Agent Name" --description "Description" --phone "+15551234567" [--profile "my-agent"]');
-        process.exit(1);
-    }
-    // Default profile name: sanitized agent name
-    const profileName = values.profile || values.name.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
-    const environmentId = values.environment || process.env.CANON_ENVIRONMENT_ID;
-    if (!environmentId) {
-        throw new Error('--environment or CANON_ENVIRONMENT_ID is required');
-    }
-    const connection = resolveCanonRuntimeConnection({
-        environmentId,
-        apiBaseUrl: values['base-url'],
-        streamUrl: values['stream-url'],
-        rtdbUrl: values['rtdb-url'],
-        firebaseWebApiKey: values['firebase-api-key'],
-    });
-    await verifyCanonRuntimeConnection(connection);
-    const existingProfile = loadProfiles()[profileName];
-    const existingAgentId = existingProfile?.environmentId === connection.environmentId
-        ? existingProfile.agentId
-        : undefined;
-    console.log(`Registering agent "${values.name}" (profile: ${profileName})...`);
-    const pending = getOrCreatePendingRegistration(profileName, 'claude-code', connection);
-    const result = await registerAndWaitForApproval({
-        name: values.name,
-        description: values.description,
-        ownerPhone: values.phone,
-        developerInfo: 'Claude Code plugin',
-        clientType: 'claude-code',
-        baseUrl: connection.apiBaseUrl,
-        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': {
-            if (!result.apiKey || !result.agentId || !result.agentName) {
-                console.error('Approval completed but Canon did not return a usable API key. Run this command again to resume key pickup.');
-                process.exit(1);
-            }
-            upsertAgentProfile(profileName, {
-                apiKey: result.apiKey,
-                agentId: result.agentId,
-                agentName: result.agentName,
-                registeredAt: new Date().toISOString(),
-                environmentId: connection.environmentId,
-                baseUrl: connection.apiBaseUrl,
-                streamUrl: connection.streamUrl,
-                rtdbUrl: connection.rtdbUrl,
-                firebaseApiKey: connection.firebaseWebApiKey,
-                clientType: 'claude-code',
-            });
-            if (result.requestId) {
-                await ackRegistrationApproval(connection.apiBaseUrl, result.requestId, result.pollToken);
-            }
-            clearPendingRegistration(profileName);
-            console.log(`Approved! Agent: ${result.agentName} (${result.agentId})`);
-            console.log(`Saved as profile "${profileName}" in ~/.canon/agents.json`);
-            console.log('Start it with: CANON_AGENT=' + profileName + ' canon-claude --cwd /path/to/project');
-            console.log('Keep that terminal open while you want Canon to reach the agent.');
-            console.log('Closing it, logging out, rebooting, or sleeping long enough to stop the process takes this local agent offline until you revive it.');
-            console.log('Docs: https://canonmail.com/agents/integrations');
-            break;
-        }
-        case 'rejected':
-            console.log('Registration was rejected.');
-            process.exit(1);
-            break;
-        case 'timeout':
-            console.log('Registration timed out (5 minutes). Try again later.');
-            process.exit(1);
-            break;
-    }
+    await runRegistrationCli(OPTIONS);
 }
-runCli(import.meta.url, main, (error) => {
-    console.error('[canon-register] Fatal error:', error);
-    process.exit(1);
-}, {
-    name: 'canon-register',
-    help: HELP,
-});
+registerRegistrationCli(OPTIONS);

package/dist/server.js

@@ -10,10 +10,10 @@ 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, verifyResolvedAgentEnvironment, getActiveProfile, releaseLock, upsertLocalRuntimeEntry, initRTDBAuth, writeSessionState, clearSessionState, renderCanonHostInboundContent, } from '@canonmsg/core';
+import { CanonClient, CanonStream, ApprovalManager, buildLocalRuntimeId, getActiveProfileLock, markLocalRuntimeStopped, loadProfiles, isProfileLocked, resolveCanonAgent, verifyResolvedAgentEnvironment, getActiveProfile, 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';
+import { runCli } from '@canonmsg/core';
 import { parseReplyArgs, parseSendMessageArgs, parseSetTypingArgs, } from './mcp-args.js';
 import { canonVerbToolDefinitions, executeCanonVerbTool, isCanonToolVerb, stampSendToTurnComplete, } from '@canonmsg/agent-tools';
 const HELP = `canon-channel-server — Claude Code MCP channel server for Canon
@@ -39,6 +39,7 @@ let stream = null;
 let agentContext = null;
 let approvalManager = null;
 let approvalServer = null;
+let rtdb = null;
 const conversationCache = new Map();
 const TURN_COMPLETE_METADATA = {
     turnSemantics: 'turn_complete',
@@ -486,7 +487,7 @@ async function startChannel() {
         }
     }
     // Initialize RTDB auth for session state reporting
-    initRTDBAuth(client, {
+    rtdb = initRTDBAuth(client, {
         rtdbUrl: resolvedRuntime.rtdbUrl,
         firebaseApiKey: resolvedRuntime.firebaseApiKey,
     });
@@ -524,7 +525,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({
@@ -580,7 +581,7 @@ export async function main() {
         // Mark all conversations as inactive
         if (agentContext) {
             for (const convoId of conversationCache.keys()) {
-                clearSessionState(convoId, agentContext.agentId).catch(() => { });
+                rtdb?.clearSessionState(convoId, agentContext.agentId).catch(() => { });
             }
         }
         approvalManager?.dispose();

package/dist/session-state.d.ts

@@ -165,6 +165,8 @@ export declare function shouldApplyClaudeEchoedSessionState(input: {
     echoed: ClaudeSessionRunState | undefined;
     /** An input is mid-dispatch: reserved by the host, not yet with the SDK. */
     dispatching: boolean;
+    /** The SDK has accepted a Canon input whose turn has not completed. */
+    active: boolean;
     /** A final is still being handed to Canon; the turn is not over. */
     hasPendingFinalDelivery: boolean;
 }): boolean;
@@ -478,34 +480,19 @@ export declare function composeClaudeFinalText(input: {
     streamedText?: string | null;
     failureNotice?: string | null;
 }): string | null;
-export type ClaudeFinalDeliveryFailure = 'retry' | 'permanent' | 'already-delivered';
+export type ClaudeFinalDeliveryFailure = 'retry' | 'permanent';
 /**
  * How the host should react to a failed final-reply send.
  *
  * Core's `isRetryableCanonDeliveryError` is already right about what a retry
  * can fix (429, 5xx, transport errors); what the host lacked was the other
  * half — everything else is PERMANENT and must be surfaced instead of retried.
- * A 409 from the server's idempotency guard means a message already exists
- * under this id, so the reply is durable: that is a success, not a failure.
- *
- * A CHUNKED final is the exception (#616's rule, kept). A chunked send is N
- * sequential messages that abort on the first failure, so a 409 says only that
- * ONE part id is taken, with nothing to say which — and since the part ids are
- * a pure hash of agent + conversation + turnKey, an id can be taken by an
- * ENTIRELY DIFFERENT answer to the same inbound message, written by a previous
- * process. Reading that as "the final is delivered" would finalize the turn
- * with the tail never sent, so it stays 'permanent': a stops-short notice beats
- * silently dropping the end of an answer.
- *
- * Resume support does not soften this. Core absorbs the one conflict that IS
- * provably ours — the first part of a resumed attempt, whose write may have
- * landed before its response was lost — and reports every other one, so a
- * conflict reaching this function is precisely the case that must not be read
- * as success.
- */
-export declare function classifyFinalDeliveryFailure(error: unknown, options?: {
-    chunked?: boolean;
-}): ClaudeFinalDeliveryFailure;
+ * Exact message-id replays return success with `created: false`. A 409 from the
+ * server's idempotency guard therefore means the stored payload differs from
+ * this final and is permanent; treating it as delivered would retire a turn
+ * whose answer was never accepted.
+ */
+export declare function classifyFinalDeliveryFailure(error: unknown): ClaudeFinalDeliveryFailure;
 /**
  * The pending-delivery record for a final that has to be retried, carrying the
  * progress the next attempt needs.

package/dist/session-state.js

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { USAGE_LIMIT_ERROR_PREFIXES } from '@anthropic-ai/claude-agent-sdk';
-import { DEFAULT_CHUNKED_MESSAGE_TEXT_MAX_BYTES, isCanonMessageIdConflict, isRetryableCanonDeliveryError, utf8ByteLength, VERB_LIMITS, } from '@canonmsg/core';
+import { DEFAULT_CHUNKED_MESSAGE_TEXT_MAX_BYTES, isRetryableCanonDeliveryError, utf8ByteLength, VERB_LIMITS, } from '@canonmsg/core';
 import { boundTrailBlockMap, buildTrailBlockId, buildUndeliverableFinalNotice as buildHostUndeliverableFinalNotice, normalizePlanStepStatus, normalizeTrailKey, PLAN_BLOCK_TITLE, renderPlanSteps, truncateFailureDetail, } from '@canonmsg/coding-agent-host';
 export function createClaudeInputEnvelope(input) {
     const sourceMessageId = input.sourceMessageId ?? null;
@@ -163,7 +163,7 @@ export function isClaudeTurnSlotReserved(state) {
 export function shouldApplyClaudeEchoedSessionState(input) {
     if (input.echoed !== 'idle')
         return true;
-    return !input.dispatching && !input.hasPendingFinalDelivery;
+    return !input.dispatching && !input.active && !input.hasPendingFinalDelivery;
 }
 /** Claim the slot for an input about to be dispatched. Must precede any await. */
 export function reserveClaudeTurnSlot(session) {
@@ -775,28 +775,12 @@ export function composeClaudeFinalText(input) {
  * Core's `isRetryableCanonDeliveryError` is already right about what a retry
  * can fix (429, 5xx, transport errors); what the host lacked was the other
  * half — everything else is PERMANENT and must be surfaced instead of retried.
- * A 409 from the server's idempotency guard means a message already exists
- * under this id, so the reply is durable: that is a success, not a failure.
- *
- * A CHUNKED final is the exception (#616's rule, kept). A chunked send is N
- * sequential messages that abort on the first failure, so a 409 says only that
- * ONE part id is taken, with nothing to say which — and since the part ids are
- * a pure hash of agent + conversation + turnKey, an id can be taken by an
- * ENTIRELY DIFFERENT answer to the same inbound message, written by a previous
- * process. Reading that as "the final is delivered" would finalize the turn
- * with the tail never sent, so it stays 'permanent': a stops-short notice beats
- * silently dropping the end of an answer.
- *
- * Resume support does not soften this. Core absorbs the one conflict that IS
- * provably ours — the first part of a resumed attempt, whose write may have
- * landed before its response was lost — and reports every other one, so a
- * conflict reaching this function is precisely the case that must not be read
- * as success.
+ * Exact message-id replays return success with `created: false`. A 409 from the
+ * server's idempotency guard therefore means the stored payload differs from
+ * this final and is permanent; treating it as delivered would retire a turn
+ * whose answer was never accepted.
  */
-export function classifyFinalDeliveryFailure(error, options = {}) {
-    if (isCanonMessageIdConflict(error) && !options.chunked) {
-        return 'already-delivered';
-    }
+export function classifyFinalDeliveryFailure(error) {
     return isRetryableCanonDeliveryError(error) ? 'retry' : 'permanent';
 }
 /**

package/dist/setup.js

@@ -9,7 +9,7 @@
 import { mkdirSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { runCli } from './cli-entry.js';
+import { runCli } from '@canonmsg/core';
 const HELP = `canon-setup — install Claude Code Canon skills and print MCP setup
 
 USAGE
@@ -47,23 +47,21 @@ function installSkills() {
 }
 // ── Show MCP config instructions ───────────────────────────────────────
 function showMcpInstructions() {
-    // Find the installed server.js path
-    const serverPath = join(__dirname, 'server.js');
     console.log(`
 Add this to your project's .mcp.json (or ~/.mcp.json for global):
 
 {
   "mcpServers": {
     "canon-channel": {
-      "command": "node",
-      "args": ["${serverPath}"]
+      "command": "canon-channel-server"
     }
   }
 }
 
 Then start Claude Code with:
 
-  claude --dangerously-load-development-channels server:canon-channel
+  CANON_API_KEY=agk_live_... CANON_ENVIRONMENT_ID=canon-prod-v1 \
+    claude --dangerously-load-development-channels server:canon-channel
 `);
 }
 // ── Main ───────────────────────────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.29.0",
+  "version": "0.29.2",
   "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/index.js",
@@ -31,11 +31,11 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.220",
-    "@canonmsg/agent-sdk": "^7.1.2",
-    "@canonmsg/agent-tools": "^0.3.1",
-    "@canonmsg/coding-agent-host": "^0.3.0",
-    "@canonmsg/core": "^8.1.0",
-    "@canonmsg/rich-cards": "^0.8.5",
+    "@canonmsg/agent-sdk": "^8.0.0",
+    "@canonmsg/agent-tools": "^0.3.3",
+    "@canonmsg/coding-agent-host": "^0.4.0",
+    "@canonmsg/core": "^9.0.0",
+    "@canonmsg/rich-cards": "^0.8.7",
     "@modelcontextprotocol/sdk": "^1.29.0"
   },
   "engines": {

package/skills/configure/SKILL.md

@@ -1,50 +1,59 @@
 ---
 name: canon-configure
-description: Configure an existing Canon agent API key
+description: Use an existing Canon agent API key with Claude Code
 user-invocable: true
 allowed-tools:
   - Read
   - Write
 ---
 
-# Configure Canon API Key
+# Use an existing Canon API key
 
-Add an existing Canon agent API key as a named profile.
+Point Claude Code at a Canon agent key the user already has.
+
+## Hard rule
+
+Never write or edit `~/.canon/agents.json`. A stored profile must carry the agent
+identity **and** a complete environment-bound endpoint set (`agentId`,
+`environmentId`, `baseUrl`, `streamUrl`, `rtdbUrl`, `firebaseApiKey`), and every
+entry is validated in one pass on load — a single hand-written entry makes the
+whole file unloadable for every Canon host on that machine. Only the register
+CLI writes profiles.
 
 ## Steps
 
 1. Ask the user for:
-   - **API key** — must start with `agk_live_`
-   - **Profile name** — a short identifier (e.g., "my-agent", "reviewer")
-   - **Agent name** (optional) — display name for reference
-
-2. Validate the API key format — it must start with `agk_live_` and be non-empty.
+   - **API key** — starts with `agk_live_`
+   - **Canon environment** — `canon-prod-v1` for production, `canon-dev-v1` for dev
 
-3. Read the existing profiles from `~/.canon/agents.json` (create if missing).
+2. Give them the launch command for the key. Nothing is stored; the key lives in
+   the environment of the process they start:
 
-4. Add/update the profile:
-   ```json
-   {
-     "<profile>": {
-       "apiKey": "<key>",
-       "agentId": "",
-       "agentName": "<name or 'Unknown'>",
-       "registeredAt": "<current ISO date>"
-     }
-   }
+   ```bash
+   CANON_API_KEY=<key> CANON_ENVIRONMENT_ID=<environment> canon-claude --cwd /path/to/project
    ```
 
-5. Write the updated profiles to `~/.canon/agents.json`.
+   `CANON_ENVIRONMENT_ID` is required with a raw key — without it the host exits
+   before connecting. Sessions started this way are shown as
+   manual/non-revivable by `canon-necromance`, because no secret-bearing state is
+   persisted.
 
-6. Tell the user: **"API key saved as profile '<profile>'. Restart Claude Code to connect."**
+3. If the user wants a stored, revivable profile instead, run `/canon-register`.
+   Registration is the only path that writes `~/.canon/agents.json`; re-running it
+   with an existing `--profile` name refreshes that profile's credential in place.
+
+4. Once a profile exists, it can be pinned for channel mode in `.mcp.json`:
 
-   If they have multiple agents and want to pin one, add to `.mcp.json`:
    ```json
    {
      "mcpServers": {
        "canon-channel": {
+         "command": "canon-channel-server",
          "env": { "CANON_AGENT": "<profile>" }
        }
      }
    }
    ```
+
+   `CANON_AGENT` is required as soon as more than one profile exists — the host
+   refuses to guess between them.

package/skills/register/SKILL.md

@@ -18,7 +18,7 @@ Register a new Canon agent so it can send and receive messages. Each agent is sa
    - **Agent name** — The display name for the agent in Canon
    - **Description** — What the agent does (shown to users in Canon)
    - **Owner phone number** — The Canon account owner's phone number in E.164 format (e.g., +15551234567)
-   - **Canon environment** — The trust-domain ID supplied by Canon (production defaults to `canon-prod-v1`)
+   - **Canon environment** — The trust-domain ID supplied by Canon (`canon-prod-v1` for production, `canon-dev-v1` for dev). There is no CLI default; the command fails without it.
    - **Profile name** (optional) — A short identifier for this agent (e.g., "reviewer", "notifier"). Defaults to a sanitized version of the agent name.
 
 2. Run the registration CLI:
@@ -26,18 +26,23 @@ Register a new Canon agent so it can send and receive messages. Each agent is sa
    canon-register --environment "<environment>" --name "<name>" --description "<description>" --phone "<phone>" --profile "<profile>"
    ```
 
+   `CANON_ENVIRONMENT_ID=<environment>` in the environment is equivalent to `--environment`.
+
 3. Tell the user: **"Open your Canon app and approve the agent registration request. Waiting for approval..."**
 
    The CLI will poll automatically for up to 5 minutes.
 
 4. On approval, the CLI saves the agent to `~/.canon/agents.json` automatically.
 
-5. Tell the user: **"Agent registered! Run `canon-claude` to start. Or specify a project: `canon-claude --cwd /path/to/project`"**
+5. Tell the user: **"Agent registered! Start it with `CANON_AGENT=<profile> canon-claude`. Or specify a project: `CANON_AGENT=<profile> canon-claude --cwd /path/to/project`"**
+
+   `CANON_AGENT` is required once more than one profile exists — the host refuses to guess between them.
 
 ## Error handling
 
 - If the registration fails, show the error and ask the user to retry.
 - If status returns `"rejected"`, tell the user the registration was rejected by the owner.
 - If polling times out after 5 minutes, tell the user to try again later.
-- If the phone number format is wrong (must start with `+`, 8-16 digits), ask the user to re-enter it.
+- If the server returns `Invalid phone number format`, the number could not be parsed as a real number; ask the user to re-enter it in full E.164 form (`+<country code><number>`).
+- If the server returns `Owner phone number not found on platform`, the number is valid but no Canon account uses it; ask the user for the phone number of their Canon account.
 - If environment verification fails, do not retry against another URL. Confirm the environment ID and endpoint set with the user.

package/dist/cli-entry.d.ts

@@ -1,2 +0,0 @@
-export { handleCliMetadataRequest, isDirectExecution, readCliPackageVersion, runCli, } from '@canonmsg/core';
-export type { CliMetadata, RunCliMetadataOptions, } from '@canonmsg/core';

package/dist/cli-entry.js

@@ -1 +0,0 @@
-export { handleCliMetadataRequest, isDirectExecution, readCliPackageVersion, runCli, } from '@canonmsg/core';

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,54 +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.
- *
- * Claude also accepts legacy cursor candidates so it can migrate old
- * execution-mode-scoped state into one conversation-level recovery cursor.
- */
-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;
-    metadata?: Record<string, unknown>;
-}
-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;
-    /** Cursor found in history and used for this recovery pass. */
-    cursor: string | null;
-    /** Missed inbound messages (own messages excluded), oldest first. */
-    messages: TPage['messages'];
-    /** First page fetched — reusable as hydration context for recovered turns. */
-    newestPage: TPage;
-}
-/**
- * Startup recovery runs before the stream starts. The first SSE connection
- * therefore needs no second pass, while later reconnects still need catch-up.
- */
-export declare function createReconnectRecoveryGate(): () => boolean;
-export declare function collectMissedInboundMessages<TPage extends StartupRecoveryPage>(input: {
-    fetchPage: (before?: string) => Promise<TPage>;
-    cursor: string | null | undefined;
-    cursorCandidates?: readonly string[];
-    agentId: string;
-    maxMessages?: number;
-}): Promise<StartupRecoveryResult<TPage>>;

package/dist/startup-recovery.js

@@ -1,102 +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.
- *
- * Claude also accepts legacy cursor candidates so it can migrate old
- * execution-mode-scoped state into one conversation-level recovery cursor.
- */
-export const STARTUP_RECOVERY_PAGE_SIZE = 25;
-export const STARTUP_RECOVERY_MAX_MESSAGES = 500;
-/**
- * Startup recovery runs before the stream starts. The first SSE connection
- * therefore needs no second pass, while later reconnects still need catch-up.
- */
-export function createReconnectRecoveryGate() {
-    let hasConnected = false;
-    return () => {
-        const shouldRecover = hasConnected;
-        hasConnected = true;
-        return shouldRecover;
-    };
-}
-export async function collectMissedInboundMessages(input) {
-    const maxMessages = input.maxMessages ?? STARTUP_RECOVERY_MAX_MESSAGES;
-    const newestPage = await input.fetchPage();
-    const collected = [...newestPage.messages];
-    const seenIds = new Set(collected.map((message) => message.id));
-    const candidateCursorIds = new Set(input.cursor
-        ? [input.cursor]
-        : (input.cursorCandidates ?? []).filter(Boolean));
-    const foundCursorIds = new Set();
-    const recordFoundCursors = (messages) => {
-        for (const message of messages) {
-            if (candidateCursorIds.has(message.id))
-                foundCursorIds.add(message.id);
-        }
-    };
-    const cursorSearchComplete = () => foundCursorIds.size > 0;
-    const findNewestCursor = (messages) => messages.find((message) => candidateCursorIds.has(message.id))?.id ?? null;
-    recordFoundCursors(collected);
-    if (candidateCursorIds.size > 0) {
-        while (!cursorSearchComplete() && collected.length < maxMessages) {
-            // Pages are newest-first, so the last collected message is the oldest.
-            const before = collected[collected.length - 1]?.id;
-            if (!before)
-                break;
-            const page = await input.fetchPage(before);
-            const fresh = page.messages.filter((message) => !seenIds.has(message.id));
-            // No pagination progress (history exhausted, or the server ignored the
-            // `before` cursor because that message was hard-deleted) — stop here.
-            if (fresh.length === 0)
-                break;
-            for (const message of fresh)
-                seenIds.add(message.id);
-            collected.push(...fresh);
-            recordFoundCursors(fresh);
-        }
-    }
-    const resolvedCursor = cursorSearchComplete()
-        ? findNewestCursor(collected)
-        : null;
-    // Preserve the API's deterministic newest-first order. Timestamps are
-    // display data and may be equal or absent, so reversing wire order is the
-    // only lossless oldest-first replay sequence.
-    const ascending = [...collected].reverse();
-    const completedSourceMessageIds = new Set(collected.flatMap((message) => {
-        if (message.senderId !== input.agentId)
-            return [];
-        const metadata = message.metadata;
-        if (metadata?.turnSemantics !== 'turn_complete')
-            return [];
-        return typeof metadata.sourceMessageId === 'string'
-            ? [metadata.sourceMessageId]
-            : [];
-    }));
-    const inboundOnly = (messages) => messages.filter((message) => message.senderId !== input.agentId && !completedSourceMessageIds.has(message.id));
-    let mode;
-    let missed;
-    if (resolvedCursor) {
-        const cursorIndex = ascending.findIndex((message) => message.id === resolvedCursor);
-        mode = 'after-cursor';
-        missed = inboundOnly(ascending.slice(cursorIndex + 1));
-    }
-    else if (candidateCursorIds.size > 0 && collected.length >= maxMessages) {
-        mode = 'truncated-window';
-        missed = inboundOnly(ascending.slice(-maxMessages));
-    }
-    else {
-        mode = 'latest-only';
-        missed = inboundOnly(ascending).slice(-1);
-    }
-    // Safe: `missed` only holds elements of pages returned by `fetchPage`.
-    return {
-        mode,
-        cursor: resolvedCursor,
-        messages: missed,
-        newestPage,
-    };
-}

package/dist/streaming-buffer.d.ts

@@ -1,16 +0,0 @@
-export interface StreamingBufferOptions {
-    throttleMs: number;
-    getText: () => string;
-    setText: (text: string) => void;
-    getTimer: () => ReturnType<typeof setTimeout> | null;
-    setTimer: (timer: ReturnType<typeof setTimeout> | null) => void;
-    onWrite: (text: string) => void;
-    schedule?: typeof setTimeout;
-    cancel?: typeof clearTimeout;
-}
-export declare function createStreamingBuffer(options: StreamingBufferOptions): {
-    append(delta: string): void;
-    flush: () => void;
-    clear(): void;
-    replace(text: string): void;
-};

package/dist/streaming-buffer.js

@@ -1,52 +0,0 @@
-export function createStreamingBuffer(options) {
-    const schedule = options.schedule ?? setTimeout;
-    const cancel = options.cancel ?? clearTimeout;
-    const flush = () => {
-        const timer = options.getTimer();
-        if (timer) {
-            cancel(timer);
-            options.setTimer(null);
-        }
-        const text = options.getText();
-        if (text) {
-            options.onWrite(text);
-        }
-    };
-    return {
-        append(delta) {
-            if (!delta)
-                return;
-            options.setText(`${options.getText()}${delta}`);
-            if (options.getTimer())
-                return;
-            const timer = schedule(() => {
-                options.setTimer(null);
-                const text = options.getText();
-                if (text) {
-                    options.onWrite(text);
-                }
-            }, options.throttleMs);
-            options.setTimer(timer);
-        },
-        flush,
-        clear() {
-            const timer = options.getTimer();
-            if (timer) {
-                cancel(timer);
-                options.setTimer(null);
-            }
-            options.setText('');
-        },
-        replace(text) {
-            const timer = options.getTimer();
-            if (timer) {
-                cancel(timer);
-                options.setTimer(null);
-            }
-            options.setText(text);
-            if (text) {
-                options.onWrite(text);
-            }
-        },
-    };
-}