@canonmsg/claude-code-plugin 0.34.2 → 0.34.4

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.34.2",
+  "version": "0.34.4",
   "channels": [
     {
       "server": "canon-channel",

package/dist/host.d.ts

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
-import { type PermissionResult, type SDKControlReloadPluginsResponse } from '@anthropic-ai/claude-agent-sdk';
+import { type PermissionResult, type Query, type SDKControlReloadPluginsResponse, type SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
 import { type RecoveryCheckpointTracker } from '@canonmsg/coding-agent-host';
-import { type CanonRuntimeCommandDescriptor, type ExecutionEnvironmentMode, type HostInboundParticipantContext as InboundParticipantContext, type CanonReplyContext, type MessageCreatedPayload, type ResolvedAgentBehaviorPolicy, type TurnVerbosityConfig } from '@canonmsg/core';
+import { type CanonRuntimeCommandDescriptor, type CanonRuntimeDescriptor, type CanonRuntimeFact, type CanonRuntimePresentationPolicy, type ExecutionEnvironmentMode, type DeliveryIntent, type ModelOption, type HostInboundParticipantContext as InboundParticipantContext, type CanonReplyContext, type MessageCreatedPayload, type ResolvedAgentBehaviorPolicy, type TurnLifecycleState, type TurnVerbosity, type TurnVerbosityConfig, type PreparedExecutionEnvironment, type WorkspaceOption, type CanonWorkspaceRootMetadata } from '@canonmsg/core';
+import { type ClaudeInputEnvelope, type ClaudePendingFinalDelivery, type ClaudeTurnActivityState, type ClaudeTurnModes, type ClaudeRuntimeControlError } from './session-state.js';
 /**
  * `--turn-verbosity` beats `CANON_TURN_VERBOSITY`; `null` means "unset, use the
  * per-conversation-type default".
@@ -19,13 +20,92 @@ export declare function resolveConfiguredClaudeTurnVerbosity(input: {
 }): TurnVerbosityConfig | null;
 export declare function buildClaudePlanAllowResult(input: Record<string, unknown>): PermissionResult;
 /**
- * Claude Code's own slash commands (built-ins, plugins, project .claude/
- * commands) are executable when sent as prompt text, so the runtime's command
- * inventory is exposed as composer slash entries that pass the raw slash text
- * through. Canon-injected aliases keep precedence over native names.
+ * Publish only commands returned by the SDK, using its canonical name and
+ * aliases. Reserve aliases only for implemented Canon session actions.
  */
 export declare function buildNativeSlashCommandDescriptors(native: SDKControlReloadPluginsResponse['commands'], reservedAliases: ReadonlySet<string>): CanonRuntimeCommandDescriptor[];
+export declare function buildClaudeRuntimeDescriptor(input: {
+    nativeCommands?: SDKControlReloadPluginsResponse['commands'];
+    models: ModelOption[];
+    workspaces: WorkspaceOption[];
+    workspaceRoots?: CanonWorkspaceRootMetadata[];
+    executionModes: ExecutionEnvironmentMode[];
+    defaultExecutionMode?: ExecutionEnvironmentMode;
+    presentation?: CanonRuntimePresentationPolicy;
+}): CanonRuntimeDescriptor;
 export declare function resolveSessionExecutionMode(defaultExecutionMode?: ExecutionEnvironmentMode): ExecutionEnvironmentMode;
+interface SessionState {
+    model?: string;
+    permissionMode?: string;
+    effort?: string;
+    ultracode?: string;
+    state?: 'idle' | 'running' | 'requires_action';
+    contextUsage?: {
+        percentage: number;
+        totalTokens: number;
+        maxTokens: number;
+    };
+}
+interface Session {
+    observedModel?: string;
+    observedEffort?: string;
+    conversationId: string;
+    cwd: string;
+    environment: PreparedExecutionEnvironment;
+    query: Query;
+    sendInput: (input: ClaudeInputEnvelope) => void;
+    enqueueInbound: (msg: SDKUserMessage, intent?: DeliveryIntent, sourceMessageId?: string | null, markAccepted?: boolean, isOwnerTurn?: boolean, requestingUserId?: string | null, turnModes?: ClaudeTurnModes) => void;
+    state: SessionState;
+    availableModels: ModelOption[];
+    /**
+     * The verbosity the RUNNING turn was opened with. Re-affirmed from each
+     * turn's envelope at `openTurn` and never re-read mid-turn: Claude replays a
+     * final's metadata byte-for-byte across delivery retries, so a trail that
+     * appeared or vanished between attempts would turn a harmless replay into a
+     * 409.
+     */
+    turnVerbosity: TurnVerbosity;
+    streamingText: string;
+    streamingTimer: ReturnType<typeof setTimeout> | null;
+    idleResetTimer: ReturnType<typeof setTimeout> | null;
+    finalDeliveryTimer: ReturnType<typeof setTimeout> | null;
+    pendingInputs: ClaudeInputEnvelope[];
+    activeInput: ClaudeInputEnvelope | null;
+    /**
+     * The input being dispatched: the slot is reserved but the SDK does not have
+     * it yet. Only an interrupt cares — there is nothing in flight to stop.
+     */
+    dispatchingInput: ClaudeInputEnvelope | null;
+    finalizedTurnKeys: Set<string>;
+    interruptedTurnKeys: Set<string>;
+    /** Turns whose model called `no_reply`: end without posting anything. */
+    silencedTurnKeys: Set<string>;
+    pendingFinalText: string | null;
+    pendingFinalDelivery: ClaudePendingFinalDelivery | null;
+    runtimeControlErrors: Record<string, ClaudeRuntimeControlError>;
+    toolInProgress: boolean;
+    turnState: TurnLifecycleState;
+    currentTurnId: string | null;
+    currentTurnOpenedAt: number | null;
+    currentTurnUpdatedAt: number | null;
+    /** Per-turn margin-trail bookkeeping (one block per tool call). */
+    turnActivity: ClaudeTurnActivityState;
+    activeSelfContextId: string | null;
+    lastAcceptedIntent: DeliveryIntent | null;
+    lastActivity: number;
+    typingKeepaliveTimer: ReturnType<typeof setInterval> | null;
+    controlInterruptPending: boolean;
+    closed: boolean;
+    /** SDK session ID — captured from result messages for resume support */
+    sdkSessionId: string | null;
+    writeState: () => void;
+    writeTurn: () => void;
+    clearStreaming: () => Promise<void>;
+    markInputCompleted: (input: ClaudeInputEnvelope | null | undefined) => void;
+    setRuntimeControlError: (controlId: string, value: string, error: unknown) => void;
+    clearRuntimeControlError: (controlId: string) => void;
+}
+export declare function buildClaudeSessionFacts(session?: Pick<Session, 'closed' | 'observedModel' | 'observedEffort'>): CanonRuntimeFact[];
 export declare function createClaudeRecoveryCheckpointTracker(persist: (messageId: string) => boolean): RecoveryCheckpointTracker;
 export declare const NO_REPLY_TOOL_NAME: string;
 export declare function buildCanonPrompt(input: {
@@ -40,3 +120,4 @@ export declare function buildCanonPrompt(input: {
     message?: MessageCreatedPayload['message'];
 }): string;
 export declare function main(): Promise<void>;
+export {};

package/dist/host.js

@@ -29,6 +29,7 @@ import { query, } from '@anthropic-ai/claude-agent-sdk';
 import { materializeMessageMedia, materializeReplyContextMedia, sendMediaFileMessage, } from '@canonmsg/agent-sdk';
 import { captureTurnArtifactSnapshot, createTurnArtifactRouter, IDLE_TIMEOUT_MS, collectMissedInboundMessages, createRecoveryCheckpointTracker, createReconnectRecoveryCoordinator, STARTUP_RECOVERY_PAGE_SIZE, } from '@canonmsg/coding-agent-host';
 import { buildCanonUserContent, renderClaudeInboundContent, withClaudeReplyContextMediaReferences, } from './canon-user-content.js';
+import { buildClaudeNativeCommandInput, createClaudeCommandContextHook, getClaudeNativeCommandOutput, } from './native-command-input.js';
 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, createConversationMetadataLoader, createTurnOutputController, createRuntimeStatePublisher, createRuntimeHeartbeat, createTypingStatusPublisher, EXECUTION_ENVIRONMENT_MODES, ExecutionEnvironmentError, CanonClient, CanonStream, ControlChannelPoller, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, HOST_ADMISSION_ACTIONS_DISABLED, ApprovalManager, RuntimeRequestManager, FINAL_MESSAGE_HANDOFF_MS, buildLocalRuntimeId, getActiveProfileLock, heartbeatLocalRuntimeEntry, normalizeTurnMetadata, parseTurnVerbosityConfig, prepareConversationEnvironment, resolveCanonAgent, verifyResolvedAgentEnvironment, decideAutoReply, initRTDBAuth, isChunkedSendMessageError, sendMessageWithRetry, sendMessageWithRetryChunked, loadRuntimeSessionState, markLocalRuntimeStopped, releaseConversationEnvironment, resolveLocalRuntimeSessionState, saveRuntimeSessionState, clearRuntimeSessionState, publishHostSessionSnapshots, renderCodingHostInboundPrompt, resolveConfiguredWorkspaceCwd, resolveTurnVerbosity, shouldTriggerAgentTurn, upsertLocalRuntimeEntry, } from '@canonmsg/core';
 import { runCli } from '@canonmsg/core';
 import { CANON_VERB_MCP_SERVER_NAME, createCanonVerbMcpServer } from '@canonmsg/agent-tools';
@@ -134,16 +135,14 @@ export function buildClaudePlanAllowResult(input) {
     return { behavior: 'allow', updatedInput: input };
 }
 /**
- * Claude Code's own slash commands (built-ins, plugins, project .claude/
- * commands) are executable when sent as prompt text, so the runtime's command
- * inventory is exposed as composer slash entries that pass the raw slash text
- * through. Canon-injected aliases keep precedence over native names.
+ * Publish only commands returned by the SDK, using its canonical name and
+ * aliases. Reserve aliases only for implemented Canon session actions.
  */
 export function buildNativeSlashCommandDescriptors(native, reservedAliases) {
     const descriptors = [];
-    for (const command of native.slice(0, MAX_NATIVE_SLASH_COMMANDS)) {
+    for (const command of native) {
         const name = String(command.name ?? '').replace(/^\//, '').trim();
-        if (!name)
+        if (!/^[A-Za-z0-9:_-]+$/.test(name))
             continue;
         descriptors.push({
             id: `claude-native-${name}`,
@@ -151,12 +150,13 @@ export function buildNativeSlashCommandDescriptors(native, reservedAliases) {
             description: command.description
                 ?? ('argumentHint' in command ? command.argumentHint : undefined)
                 ?? 'Claude Code command (runs in the runtime).',
-            aliases: [name],
+            aliases: [name, ...(command.aliases ?? []).filter((alias) => /^\/?[A-Za-z0-9:_-]+$/.test(alias))],
             category: 'runtime',
             placements: ['composer_slash', 'command_palette'],
             availability: ['always'],
             trailingTextBehavior: 'send_as_prompt',
-            dispatch: { kind: 'text_passthrough', template: `/${name}` },
+            args: [{ id: 'prompt', label: 'Arguments', kind: 'string', captureRemaining: true }],
+            dispatch: { kind: 'text_passthrough', template: `/${name} {argument}` },
         });
     }
     return normalizeRuntimeCommandDescriptors(descriptors, {
@@ -164,100 +164,19 @@ export function buildNativeSlashCommandDescriptors(native, reservedAliases) {
         maxCommands: MAX_NATIVE_SLASH_COMMANDS,
     });
 }
-function buildClaudeRuntimeDescriptor(input) {
+export function buildClaudeRuntimeDescriptor(input) {
     const commands = [
         {
             id: 'runtime-status',
-            label: 'Runtime status',
-            description: 'Open Claude runtime details, including account, project, and policy status.',
+            label: 'Session info',
+            description: 'Open Canon session information.',
             primitive: 'runtime.status',
-            aliases: ['status'],
+            aliases: ['session-info'],
             category: 'details',
             placements: ['composer_slash', 'command_palette'],
             availability: ['always'],
             dispatch: { kind: 'open_details', target: 'status' },
         },
-        {
-            id: 'mcp-inventory',
-            label: 'MCP servers',
-            description: 'Open the Claude MCP inventory published by the host.',
-            aliases: ['mcp'],
-            category: 'details',
-            placements: ['composer_slash', 'command_palette'],
-            availability: ['always'],
-            dispatch: { kind: 'open_details', target: 'mcp' },
-        },
-        {
-            id: 'plugin-inventory',
-            label: 'Plugins',
-            description: 'Open the Claude plugin and command inventory published by the host.',
-            aliases: ['plugins'],
-            category: 'details',
-            placements: ['composer_slash', 'command_palette'],
-            availability: ['always'],
-            dispatch: { kind: 'open_details', target: 'plugins' },
-        },
-        {
-            id: 'model-details',
-            label: 'Model control',
-            description: 'Open runtime details and use the live Model control.',
-            aliases: ['model'],
-            category: 'details',
-            placements: ['composer_slash', 'command_palette'],
-            availability: ['always'],
-            dispatch: { kind: 'open_details', target: 'model' },
-        },
-        {
-            id: 'permission-details',
-            label: 'Permission mode',
-            description: 'Open runtime details and use the live Permission mode control.',
-            aliases: ['permission'],
-            category: 'details',
-            placements: ['composer_slash', 'command_palette'],
-            availability: ['always'],
-            dispatch: { kind: 'open_details', target: 'permissionMode' },
-        },
-        {
-            id: 'effort-details',
-            label: 'Thinking level',
-            description: 'Set Claude effort using /effort or /think.',
-            primitive: 'runtime.reasoning.set',
-            aliases: ['effort', 'think'],
-            category: 'runtime',
-            placements: ['composer_slash', 'command_palette'],
-            availability: ['always'],
-            args: [{
-                    id: 'level',
-                    label: 'Level',
-                    kind: 'enum',
-                    required: true,
-                    choices: [...EFFORT_OPTIONS],
-                }],
-            dispatch: {
-                kind: 'control',
-                controlId: 'effort',
-            },
-        },
-        {
-            id: 'ultracode-details',
-            label: 'Ultracode',
-            description: 'Toggle Claude ultracode using /ultracode.',
-            aliases: ['ultracode'],
-            category: 'runtime',
-            placements: ['composer_slash', 'command_palette'],
-            availability: ['always'],
-            args: [{
-                    id: 'level',
-                    label: 'Level',
-                    kind: 'enum',
-                    required: true,
-                    choices: [...CLAUDE_ULTRACODE_OPTIONS],
-                }],
-            dispatch: {
-                kind: 'control',
-                controlId: 'ultracode',
-            },
-        },
         {
             ...RUNTIME_NEW_SESSION_ACTION,
             primitive: 'session.new',
@@ -265,7 +184,7 @@ function buildClaudeRuntimeDescriptor(input) {
         RUNTIME_STOP_ACTION,
         RUNTIME_STOP_AND_DROP_ACTION,
     ];
-    commands.push(...buildNativeSlashCommandDescriptors(runtimeMetadata.commands, new Set(commands.flatMap((command) => [command.id, ...(command.aliases ?? [])]))));
+    commands.push(...buildNativeSlashCommandDescriptors(input.nativeCommands ?? runtimeMetadata.commands, new Set(commands.flatMap((command) => [command.id, ...(command.aliases ?? [])]))));
     return buildFirstPartyCodingRuntimeDescriptor({
         clientType: 'claude-code',
         models: input.models,
@@ -431,14 +350,6 @@ function resolveWorkspaceCwd() {
         defaultCwd: workingDir,
     });
 }
-function resolveExecutionFallbackReason(environment) {
-    if (!environment?.reason || environment.mode !== 'locked') {
-        return null;
-    }
-    return environment.reason === 'Sharing the base workspace (locked mode)'
-        ? null
-        : environment.reason;
-}
 async function detectRuntimeModels(cwd) {
     const discovered = await detectRuntimeModelsForSelection(cwd, 'default');
     const supplemental = await detectSupplementalRuntimeModels(cwd, deriveClaudeSupplementalModelProbes(discovered));
@@ -559,146 +470,15 @@ async function readApprovalDiffPreImage(filePath) {
         throw error;
     }
 }
-function mapClaudeMcpStatus(status) {
-    switch (status) {
-        case 'connected':
-            return 'ready';
-        case 'needs-auth':
-            return 'auth_needed';
-        case 'disabled':
-            return 'configured';
-        case 'failed':
-            return 'error';
-        default:
-            return 'unknown';
-    }
-}
-function buildClaudeRuntimeInfo(input) {
-    const { descriptor, metadata } = input;
-    const statusItems = [
-        metadata.account?.email
-            ? {
-                id: 'account',
-                label: 'Account',
-                value: 'Connected',
-                tone: 'success',
-                tier: 'diagnostic',
-            }
-            : null,
-        metadata.account?.subscriptionType
-            ? {
-                id: 'subscription',
-                label: 'Plan',
-                value: metadata.account.subscriptionType,
-            }
-            : null,
-        metadata.account?.apiProvider
-            ? {
-                id: 'provider',
-                label: 'Provider',
-                value: metadata.account.apiProvider,
-            }
-            : null,
-        metadata.account?.tokenSource || metadata.account?.apiKeySource
-            ? {
-                id: 'auth',
-                label: 'Auth',
-                value: metadata.account.tokenSource ?? metadata.account?.apiKeySource ?? 'connected',
-                tier: 'diagnostic',
-            }
-            : null,
-        runtimeModels[0]
-            ? {
-                id: 'fallbackModel',
-                label: 'Fallback model',
-                value: runtimeModels[0].label,
-                tier: 'diagnostic',
-                source: 'host-default',
-            }
-            : null,
-        {
-            id: 'toolPolicy',
-            label: 'Tool policy',
-            value: 'Claude Code preset',
-            tier: 'detail',
-        },
-        {
-            id: 'browser',
-            label: 'Browser tools',
-            value: 'Runtime policy',
-            tier: 'detail',
-        },
-        {
-            id: 'mediaOut',
-            label: 'Media out',
-            value: 'Generated media artifacts',
-            tier: 'detail',
-        },
-    ].filter((item) => Boolean(item));
-    return {
-        descriptor,
-        surfaceMode: 'host',
-        statusItems,
-        inventories: [
-            {
-                id: 'mcp',
-                label: 'MCP',
-                entries: metadata.mcpServers.map((server) => ({
-                    id: server.name,
-                    label: server.name,
-                    status: mapClaudeMcpStatus(server.status),
-                    description: server.error
-                        ?? server.serverInfo?.version
-                        ?? server.scope
-                        ?? undefined,
-                })),
-                tier: 'diagnostic',
-            },
-            {
-                id: 'plugins',
-                label: 'Plugins',
-                entries: metadata.plugins.map((plugin) => ({
-                    id: plugin.name,
-                    label: plugin.name,
-                    status: 'configured',
-                    description: plugin.source ?? plugin.path,
-                })),
-                tier: 'diagnostic',
-            },
-            {
-                id: 'commands',
-                label: 'Commands',
-                entries: metadata.commands.map((command) => ({
-                    id: command.name,
-                    label: command.name.startsWith('/') ? command.name : `/${command.name}`,
-                    status: 'configured',
-                    description: command.description ?? command.argumentHint ?? undefined,
-                })),
-                tier: 'diagnostic',
-            },
-            {
-                id: 'agents',
-                label: 'Agents',
-                entries: metadata.agents.map((agent) => ({
-                    id: agent.name,
-                    label: agent.name,
-                    status: 'configured',
-                    description: agent.description ?? agent.model ?? undefined,
-                })),
-                tier: 'diagnostic',
-            },
-        ],
-        execution: {
-            resolvedWorkspaceLabel: input.workspaceLabel,
-            resolvedCwd: input.resolvedCwd,
-            workspaceRootId: input.workspaceRootId ?? null,
-            workspaceRelativePath: input.workspaceRelativePath ?? null,
-            executionMode: input.executionMode,
-            executionBranch: input.executionBranch,
-            worktreePath: input.worktreePath,
-            fallbackReason: input.fallbackReason,
-        },
-    };
+export function buildClaudeSessionFacts(session) {
+    if (!session || session.closed)
+        return [];
+    const facts = [{ id: 'runtime', label: 'Runtime', value: 'Claude Agent SDK', group: 'runtime' }];
+    if (session.observedModel)
+        facts.push({ id: 'model', label: 'Model', value: session.observedModel, group: 'model' });
+    if (session.observedEffort)
+        facts.push({ id: 'reasoning', label: 'Reasoning', value: session.observedEffort, group: 'model' });
+    return facts;
 }
 // ── Constants ───────────────────────────────────────────────────────
 const MAX_SESSIONS = 5;
@@ -841,6 +621,10 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         // from here.
         if (!claudeInputOwnsTurnSlot(input))
             return;
+        // Native commands can change settings without reporting the new value.
+        // Wait for this turn's SDK observations instead of repeating old defaults.
+        session.observedModel = undefined;
+        session.observedEffort = undefined;
         session.activeInput = input;
     }
     const inputStream = {
@@ -942,6 +726,16 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         ...(config.effort ? { effort: config.effort } : {}),
         settings: { forceLoginMethod: 'claudeai' },
         settingSources: ['project', 'local'],
+        hooks: {
+            UserPromptExpansion: [{
+                    hooks: [createClaudeCommandContextHook(() => session.activeInput?.commandContext)],
+                }],
+            Stop: [{ hooks: [async (input) => {
+                            if (!input.agent_id)
+                                session.observedEffort = input.effort?.level;
+                            return {};
+                        }] }],
+        },
         // Canonical Canon verbs, in-process (projection 2 of canon.verbs.v1).
         // Fresh instance per session: the SDK connects the instance to its own
         // in-process transport, so instances are not shared across queries.
@@ -1975,6 +1769,8 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                         // ever saw streamed.
                         if (!isClaudeMainTurnMessage(msg.parent_tool_use_id))
                             break;
+                        if (!msg.error && msg.message.model)
+                            session.observedModel = msg.message.model;
                         // The assistant message is the first place the tool call's typed
                         // INPUT is visible — content_block_start carries only the name. It
                         // is what turns "Bash" into "Running: npm test" and TodoWrite into
@@ -2091,6 +1887,10 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                     }
                     case 'system': {
                         const subtype = msg.subtype;
+                        const commandOutput = getClaudeNativeCommandOutput(msg);
+                        if (commandOutput && claudeInputOwnsTurnSlot(session.activeInput) && !isActiveTurnInterrupted()) {
+                            session.pendingFinalText = [session.pendingFinalText, commandOutput].filter(Boolean).join('\n');
+                        }
                         if (subtype === 'session_state_changed') {
                             const state = msg.state;
                             // The echo shares one field with the host's own reservation and
@@ -2541,12 +2341,11 @@ export async function main() {
         if (signal.aborted)
             return;
         const activeSessionQuery = sessions.values().next().value?.query ?? null;
-        const metadata = await refreshClaudeRuntimeMetadata({
+        await refreshClaudeRuntimeMetadata({
             cwd: workingDir,
             activeQuery: activeSessionQuery,
         }).catch((error) => {
             console.error('[canon-host] Failed to refresh Claude runtime metadata:', error);
-            return runtimeMetadata;
         });
         if (signal.aborted)
             return;
@@ -2570,27 +2369,15 @@ export async function main() {
         if (signal.aborted)
             return;
         const results = await Promise.allSettled(Array.from(knownConversationIds).map(async (conversationId) => {
-            const session = sessions.get(conversationId);
-            const workspaceId = session
-                ? resolveWorkspaceIdForBaseCwd(session.environment.baseCwd)
-                : runtimeDescriptor.defaultWorkspaceId;
-            const workspace = workspaceOptions.find((option) => option.id === workspaceId) ?? null;
             const descriptor = runtimeDescriptor.runtimeDescriptor;
             if (!descriptor)
                 return;
-            const payload = buildClaudeRuntimeInfo({
+            await runtimeState.writeRuntimeInfo(conversationId, {
+                surfaceMode: 'host',
+                // The shared publisher sanitizes configuration while retaining commands.
                 descriptor,
-                metadata,
-                workspaceLabel: workspace?.label ?? workspaceId ?? null,
-                resolvedCwd: session?.cwd ?? workspace?.cwd ?? workingDir,
-                workspaceRootId: workspace?.workspaceRootId ?? null,
-                workspaceRelativePath: workspace?.workspaceRelativePath ?? null,
-                executionMode: session?.environment.mode ?? null,
-                executionBranch: session?.environment.branch ?? null,
-                worktreePath: session?.environment.worktreePath ?? null,
-                fallbackReason: resolveExecutionFallbackReason(session?.environment),
+                facts: buildClaudeSessionFacts(sessions.get(conversationId)),
             });
-            await runtimeState.writeRuntimeInfo(conversationId, payload);
         }));
         const failure = results.find((result) => result.status === 'rejected');
         if (failure?.status === 'rejected')
@@ -2715,9 +2502,6 @@ export async function main() {
         client,
         conversationCache,
     });
-    function resolveWorkspaceIdForBaseCwd(baseCwd) {
-        return workspaceOptions.find((option) => option.cwd === baseCwd)?.id;
-    }
     async function refreshKnownConversationIds(force = false) {
         if (!force && Date.now() - lastKnownConversationRefreshAt < HEARTBEAT_MS) {
             return;
@@ -3155,11 +2939,20 @@ export async function main() {
             replyContext,
             message: m,
         });
-        const messageContent = await buildCanonUserContent({
+        const commandInput = buildClaudeNativeCommandInput({
+            text: m.text,
+            senderType: m.senderType,
             promptText,
+            commands: runtimeMetadata.commands,
+        });
+        const messageContent = await buildCanonUserContent({
+            promptText: commandInput.promptText,
             materialized: [...replyMedia.materialized, ...materialized],
         });
-        const turnModes = resolveClaudeTurnModes(participantContext);
+        const turnModes = {
+            ...resolveClaudeTurnModes(participantContext),
+            commandContext: commandInput.commandContext,
+        };
         session.enqueueInbound({
             type: 'user',
             message: {
@@ -3424,12 +3217,19 @@ export async function main() {
                         replyContext,
                         message: m,
                     });
-                    const messageContent = await buildCanonUserContent({
+                    const commandInput = buildClaudeNativeCommandInput({
+                        text: m.text,
+                        senderType: m.senderType,
                         promptText,
+                        commands: runtimeMetadata.commands,
+                    });
+                    const messageContent = await buildCanonUserContent({
+                        promptText: commandInput.promptText,
                         materialized: [...replyMedia.materialized, ...materialized],
                     });
                     const turnModes = {
                         ...resolveClaudeTurnModes(participantContext),
+                        commandContext: commandInput.commandContext,
                         replyAuthority: payload.replyAuthority ?? null,
                     };
                     session.enqueueInbound({

package/dist/native-command-input.d.ts

@@ -0,0 +1,18 @@
+import type { HookCallback, SDKControlReloadPluginsResponse } from '@anthropic-ai/claude-agent-sdk';
+/** Keep SDK command syntax intact; pass Canon context to the expansion hook. */
+export declare function buildClaudeNativeCommandInput(input: {
+    text?: string | null;
+    senderType?: string;
+    promptText: string;
+    commands: SDKControlReloadPluginsResponse['commands'];
+}): {
+    promptText: string;
+    commandContext?: string;
+};
+export declare function createClaudeCommandContextHook(getContext: () => string | undefined): HookCallback;
+/** Local SDK commands bypass assistant messages but still have a visible result. */
+export declare function getClaudeNativeCommandOutput(message: {
+    type: string;
+    subtype?: string;
+    content?: unknown;
+}): string | null;

package/dist/native-command-input.js

@@ -0,0 +1,26 @@
+/** Keep SDK command syntax intact; pass Canon context to the expansion hook. */
+export function buildClaudeNativeCommandInput(input) {
+    const text = input.text?.trim();
+    const name = text?.match(/^\/([A-Za-z0-9:_-]+)(?:\s|$)/)?.[1];
+    if (input.senderType !== 'human' || !name || !input.commands.some((command) => ([command.name, ...(command.aliases ?? [])].some((alias) => (alias.replace(/^\//, '').toLowerCase() === name.toLowerCase())))))
+        return { promptText: input.promptText };
+    return {
+        promptText: text,
+        ...(text !== input.promptText ? { commandContext: input.promptText } : {}),
+    };
+}
+export function createClaudeCommandContextHook(getContext) {
+    return async (input) => {
+        const additionalContext = getContext();
+        return input.hook_event_name === 'UserPromptExpansion' && additionalContext
+            ? { hookSpecificOutput: { hookEventName: 'UserPromptExpansion', additionalContext } }
+            : {};
+    };
+}
+/** Local SDK commands bypass assistant messages but still have a visible result. */
+export function getClaudeNativeCommandOutput(message) {
+    return message.type === 'system' && message.subtype === 'local_command_output'
+        && typeof message.content === 'string' && message.content.trim()
+        ? message.content.trim()
+        : null;
+}

package/dist/session-state.d.ts

@@ -5,6 +5,7 @@ import type { TurnArtifactRoutingDecision, TurnArtifactSnapshot } from '@canonms
 export type ClaudeInputKind = 'seed' | 'canon';
 export type ClaudeArtifactRoutingMode = 'workspace-generated' | 'disabled';
 export interface ClaudeInputEnvelope {
+    commandContext?: string;
     kind: ClaudeInputKind;
     /** Correlates this envelope with its turn result's `user_message_uuid`. */
     messageUuid: string;
@@ -32,6 +33,7 @@ export interface ClaudeInputEnvelope {
  * grouped so they travel together from the enqueue site onto the envelope.
  */
 export interface ClaudeTurnModes {
+    commandContext?: string;
     artifactRoutingMode?: ClaudeArtifactRoutingMode;
     turnVerbosity?: TurnVerbosity;
     replyAuthority?: AgentReplyAuthorityV1 | null;
@@ -96,6 +98,7 @@ export interface ClaudeCompletedTurnState {
     turnActivity?: ClaudeTurnActivityState;
 }
 export declare function createClaudeInputEnvelope(input: {
+    commandContext?: string;
     kind: ClaudeInputKind;
     msg: SDKUserMessage;
     intent?: DeliveryIntent;

package/dist/session-state.js

@@ -10,6 +10,7 @@ export function createClaudeInputEnvelope(input) {
     // from a mutable slot and arrival order.
     const messageUuid = randomUUID();
     return {
+        ...(input.commandContext ? { commandContext: input.commandContext } : {}),
         kind: input.kind,
         messageUuid,
         msg: { ...input.msg, uuid: messageUuid },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.34.2",
+  "version": "0.34.4",
   "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/index.js",
@@ -31,10 +31,10 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.228",
-    "@canonmsg/agent-sdk": "^10.2.0",
+    "@canonmsg/agent-sdk": "^10.2.1",
     "@canonmsg/agent-tools": "^0.9.0",
     "@canonmsg/coding-agent-host": "^0.7.0",
-    "@canonmsg/core": "^12.2.0",
+    "@canonmsg/core": "^12.3.1",
     "@canonmsg/rich-cards": "^0.10.4",
     "@modelcontextprotocol/sdk": "^1.30.0"
   },