@canonmsg/codex-plugin 0.1.0 → 0.2.0

package/README.md

@@ -2,12 +2,17 @@
 
 Connect the local Codex CLI to [Canon](https://github.com/HeyBobChan/canon) so a Canon user can message your coding agent from the app.
 
+The plugin uses the local user's existing Codex authentication by default. That means Canon follows whatever plan or login mode the user has configured in Codex itself, instead of asking for a separate Canon-side OpenAI credential.
+
 ## Quick start
 
 ```bash
 # Install
 npm install -g @canonmsg/codex-plugin
 
+# Make sure Codex itself is logged in the way you want Canon to use
+codex login status
+
 # Register (approve in Canon when prompted)
 canon-codex-register --name "My Codex" --description "My local coding agent" --phone "+15551234567"
 
@@ -15,6 +20,8 @@ canon-codex-register --name "My Codex" --description "My local coding agent" --p
 canon-codex --cwd /path/to/project
 ```
 
+Registration saves a Canon profile in `~/.canon/agents.json`, the same shared profile store used by the Claude Code integration and supported by the OpenClaw plugin.
+
 ## What v1 supports
 
 - Canon messages routed into Codex turns
@@ -37,9 +44,35 @@ canon-codex --cwd /path/to/project
 Useful flags:
 
 ```bash
-canon-codex --cwd /path/to/project --model gpt-5.4 --sandbox workspace-write --ask-for-approval never
+canon-codex --cwd /path/to/project --model gpt-5.4 --full-auto
+```
+
+Recent Codex CLI releases no longer accept `--ask-for-approval` with `codex exec`. If you previously launched Canon with `--sandbox workspace-write --ask-for-approval never`, switch to `--full-auto`.
+
+Local smoke test:
+
+```bash
+npm run smoke -- /path/to/project
+```
+
+## Troubleshooting
+
+If Codex reports API-key quota errors while another local tool on the same machine uses OpenAI API keys, check Codex's own stored login state:
+
+```bash
+codex login status
 ```
 
+Codex stores its credential mode in `~/.codex/auth.json`. If it says it is logged in using an API key, switch Codex back to ChatGPT/device auth without changing your other tools:
+
+```bash
+codex logout
+codex login --device-auth
+codex login status
+```
+
+Restart `canon-codex` after changing the Codex login state.
+
 ## Multiple agents
 
 ```bash

package/dist/adapter.js

@@ -101,6 +101,12 @@ export class CodexConversationAdapter {
                 case 'turn.completed':
                     onEvent({ type: 'turn.completed', usage: event.usage });
                     break;
+                case 'error':
+                    lastErrorText = normalizeErrorText(event.message) ?? lastErrorText;
+                    break;
+                case 'turn.failed':
+                    lastErrorText = normalizeErrorText(event.error?.message ?? event.message) ?? lastErrorText;
+                    break;
                 default:
                     break;
             }
@@ -157,15 +163,18 @@ export class CodexConversationAdapter {
             return args;
         }
         const args = ['exec', '--json', '--color', 'never', '-C', this.cwd, '--skip-git-repo-check'];
+        const execMode = resolveExecMode({
+            sandbox: this.sandbox,
+            approvalPolicy: this.approvalPolicy,
+            fullAuto: this.fullAuto,
+            bypassApprovalsAndSandbox: this.bypassApprovalsAndSandbox,
+        });
         if (this.model) {
             args.push('-m', this.model);
         }
         if (this.sandbox) {
             args.push('-s', this.sandbox);
         }
-        if (this.approvalPolicy) {
-            args.push('-a', this.approvalPolicy);
-        }
         if (this.codexProfile) {
             args.push('-p', this.codexProfile);
         }
@@ -175,10 +184,10 @@ export class CodexConversationAdapter {
         for (const configOverride of this.configOverrides) {
             args.push('-c', configOverride);
         }
-        if (this.fullAuto) {
+        if (execMode.fullAuto) {
             args.push('--full-auto');
         }
-        if (this.bypassApprovalsAndSandbox) {
+        if (execMode.bypassApprovalsAndSandbox) {
             args.push('--dangerously-bypass-approvals-and-sandbox');
         }
         args.push(prompt);
@@ -209,6 +218,28 @@ function normalizeMessageText(value) {
     const text = value.trim();
     return text ? text : null;
 }
+function normalizeErrorText(value) {
+    if (typeof value !== 'string')
+        return null;
+    const text = value.trim();
+    return text ? text : null;
+}
+function resolveExecMode(input) {
+    if (input.bypassApprovalsAndSandbox) {
+        return { fullAuto: false, bypassApprovalsAndSandbox: true };
+    }
+    if (input.fullAuto) {
+        return { fullAuto: true, bypassApprovalsAndSandbox: false };
+    }
+    // Newer Codex CLI releases no longer accept --ask-for-approval for `exec`.
+    // Preserve the old Canon example (`--sandbox workspace-write --ask-for-approval never`)
+    // by translating it to the supported `--full-auto` mode.
+    if (input.approvalPolicy === 'never' &&
+        (input.sandbox === 'workspace-write' || input.sandbox == null)) {
+        return { fullAuto: true, bypassApprovalsAndSandbox: false };
+    }
+    return { fullAuto: false, bypassApprovalsAndSandbox: false };
+}
 function isIgnorableCodexLog(line) {
     return [
         'Reading additional input from stdin...',

package/dist/host.js

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
 import { setDefaultResultOrder } from 'node:dns';
 setDefaultResultOrder('ipv4first');
+import { randomUUID } from 'node:crypto';
 import { parseArgs } from 'node:util';
 import { basename, resolve } from 'node:path';
-import { CanonClient, CanonStream, clearSessionState, getActiveProfile, initRTDBAuth, releaseLock, resolveCanonAgent, rtdbRead, rtdbWrite, writeSessionState, } from '@canonmsg/core';
+import { CanonClient, CanonStream, clearSessionState, clearTurnState, DEFAULT_RUNTIME_CAPABILITIES, getActiveProfile, initRTDBAuth, normalizeTurnMetadata, normalizeTurnState, releaseLock, resolveCanonAgent, rtdbRead, rtdbWrite, shouldTriggerAgentTurn, writeSessionState, writeTurnState, } from '@canonmsg/core';
+import { buildInboundContextLines, decideAutoReply, } from './inbound-policy.js';
 import { CodexConversationAdapter, } from './adapter.js';
 import { clearStoredThreadId, loadStoredThreadId, saveStoredThreadId, } from './session-store.js';
 const MAX_SESSIONS = 12;
@@ -11,6 +13,12 @@ const IDLE_TIMEOUT_MS = 30 * 60 * 1000;
 const HEARTBEAT_MS = 30_000;
 const IDLE_CHECK_MS = 60_000;
 const CONTROL_POLL_MS = 2_000;
+const CODEX_RUNTIME_CAPABILITIES = {
+    ...DEFAULT_RUNTIME_CAPABILITIES,
+    supportsInterrupt: true,
+    supportsQueue: true,
+    supportsNonFinalPermanentMessages: true,
+};
 let workingDir = process.cwd();
 let workspaceOptions = [];
 function normalizeString(value) {
@@ -19,6 +27,22 @@ function normalizeString(value) {
     const trimmed = value.trim();
     return trimmed ? trimmed : undefined;
 }
+function normalizeRuntimeTurnState(value) {
+    const normalizedTurn = normalizeTurnState(value);
+    if (normalizedTurn) {
+        return { state: normalizedTurn.state };
+    }
+    if (!value || typeof value !== 'object')
+        return null;
+    const state = value.state;
+    if (state === 'running') {
+        return { state: 'streaming' };
+    }
+    if (state === 'requires_action') {
+        return { state: 'waiting_input' };
+    }
+    return null;
+}
 function buildWorkspaceOptions(primaryCwd, configured) {
     const uniqueDirs = Array.from(new Set([primaryCwd, ...configured].map((dir) => resolve(dir))));
     const seenLabels = new Map();
@@ -69,17 +93,15 @@ function toPublicWorkspaceOptions() {
     return workspaceOptions.map(({ id, label }) => ({ id, label }));
 }
 function buildCanonPrompt(input) {
-    const ownerLine = input.isOwner
-        ? 'The sender is the verified human owner of this Canon agent.'
-        : 'The sender is a Canon user in this conversation.';
     return [
         'You are connected to Canon messaging through a Codex host wrapper.',
-        'Reply naturally to the Canon user.',
+        'Reply naturally to Canon participants.',
         'Only the last assistant message from this turn will be delivered as the permanent Canon reply.',
         'Short intermediate assistant messages may be shown as ephemeral status while you work.',
-        ownerLine,
+        ...buildInboundContextLines(input.participantContext),
+        'Canon participants may be humans or AI agents.',
+        'If the latest message came from another AI agent, avoid agent-only ping-pong and only reply when directly addressed, when a human is clearly steering, or when a reply is genuinely necessary.',
         `Conversation ID: ${input.conversationId}`,
-        `Sender: ${input.senderName}`,
         '',
         'New Canon message:',
         input.content,
@@ -87,7 +109,25 @@ function buildCanonPrompt(input) {
 }
 function renderInboundContent(message) {
     let content = message.text || '';
-    if (message.contentType === 'audio' && message.audioUrl) {
+    const attachment = message.attachments?.[0];
+    if (attachment?.kind === 'audio' && attachment.url) {
+        const duration = attachment.durationMs ? ` (${Math.round(attachment.durationMs / 1000)}s)` : '';
+        content = content
+            ? `[Voice message${duration}: ${attachment.url}]\n${content}`
+            : `[Voice message${duration}: ${attachment.url}]`;
+    }
+    else if (attachment?.kind === 'image' && attachment.url) {
+        content = content
+            ? `[Image: ${attachment.url}]\n${content}`
+            : `[Image: ${attachment.url}]`;
+    }
+    else if (attachment?.kind === 'file' && attachment.url) {
+        const label = attachment.fileName || 'File';
+        content = content
+            ? `[File: ${label} ${attachment.url}]\n${content}`
+            : `[File: ${label} ${attachment.url}]`;
+    }
+    else if (message.contentType === 'audio' && message.audioUrl) {
         const duration = message.audioDurationMs ? ` (${Math.round(message.audioDurationMs / 1000)}s)` : '';
         content = content
             ? `[Voice message${duration}: ${message.audioUrl}]\n${content}`
@@ -107,6 +147,14 @@ function summarizeCommand(command) {
     const shortened = trimmed.length > 140 ? `${trimmed.slice(0, 137)}...` : trimmed;
     return `Running: ${shortened}`;
 }
+function formatTurnFailure(errorText) {
+    if (!errorText) {
+        return 'The Codex session stopped unexpectedly before sending a final reply.';
+    }
+    const normalized = errorText.replace(/^error:\s*/i, '').trim();
+    const shortened = normalized.length > 280 ? `${normalized.slice(0, 277)}...` : normalized;
+    return `Codex failed before sending a final reply: ${shortened}`;
+}
 async function main() {
     const { values: args } = parseArgs({
         options: {
@@ -126,6 +174,9 @@ async function main() {
     });
     workingDir = (typeof args.cwd === 'string' ? args.cwd : null) || process.cwd();
     workspaceOptions = buildWorkspaceOptions(workingDir, args.workspace ?? []);
+    if (typeof args['ask-for-approval'] === 'string') {
+        console.error('[canon-codex] Note: newer Codex CLI releases do not accept --ask-for-approval for `codex exec`; Canon will translate compatible legacy usage when possible.');
+    }
     const { apiKey, agentId: profileAgentId, profile } = resolveCanonAgent({ logPrefix: '[canon-codex]' });
     console.error(`[canon-codex] Starting${profile ? ` (profile: ${profile})` : ''} in ${workingDir}`);
     const client = new CanonClient(apiKey);
@@ -150,8 +201,74 @@ async function main() {
     }
     const sessions = new Map();
     const pendingSessionCreations = new Map();
+    const conversationCache = new Map();
+    let conversationCacheLoadedAt = 0;
+    async function refreshConversationCache(force = false) {
+        if (!force && conversationCache.size > 0 && Date.now() - conversationCacheLoadedAt < 10_000) {
+            return;
+        }
+        const conversations = await client.getConversations();
+        conversationCache.clear();
+        for (const conversation of conversations) {
+            conversationCache.set(conversation.id, conversation);
+        }
+        conversationCacheLoadedAt = Date.now();
+    }
+    async function getConversationMeta(conversationId) {
+        try {
+            await refreshConversationCache();
+            const cached = conversationCache.get(conversationId);
+            if (cached)
+                return cached;
+            await refreshConversationCache(true);
+            return conversationCache.get(conversationId) ?? null;
+        }
+        catch {
+            return conversationCache.get(conversationId) ?? null;
+        }
+    }
+    async function loadSenderRuntimeState(conversationId, senderId) {
+        try {
+            const [turnState, sessionState] = await Promise.all([
+                rtdbRead(`/turn-state/${conversationId}/${senderId}`),
+                rtdbRead(`/session-state/${conversationId}/${senderId}`),
+            ]);
+            return normalizeRuntimeTurnState(turnState) ?? normalizeRuntimeTurnState(sessionState);
+        }
+        catch {
+            return null;
+        }
+    }
+    async function loadParticipantContext(input) {
+        const [conversation, recentMessages] = await Promise.all([
+            getConversationMeta(input.conversationId),
+            client.getMessages(input.conversationId, 6).catch(() => []),
+        ]);
+        const recentSenderTypes = recentMessages
+            .filter((message) => message.senderId !== agentId)
+            .map((message) => message.senderType);
+        let consecutiveAgentTurns = 0;
+        for (const senderType of recentSenderTypes) {
+            if (senderType !== 'ai_agent')
+                break;
+            consecutiveAgentTurns += 1;
+        }
+        return {
+            conversationType: conversation?.type ?? 'unknown',
+            memberCount: conversation?.memberIds?.length ?? null,
+            senderType: input.message.senderType ?? 'human',
+            senderName: input.senderName,
+            isOwner: input.isOwner,
+            mentionedAgent: Array.isArray(input.message.mentions) && input.message.mentions.includes(agentId),
+            recentSenderTypes,
+            recentHumanCount: recentSenderTypes.filter((senderType) => senderType === 'human').length,
+            recentAgentCount: recentSenderTypes.filter((senderType) => senderType === 'ai_agent').length,
+            consecutiveAgentTurns,
+        };
+    }
     function writeState(session) {
         writeSessionState(session.conversationId, agentId, {
+            lastError: session.state.lastError,
             model: session.state.model,
             cwd: session.cwd,
             hostMode: true,
@@ -160,6 +277,25 @@ async function main() {
             isActive: true,
         }).catch(() => { });
     }
+    function writeTurn(session) {
+        writeTurnState(session.conversationId, agentId, {
+            turnId: session.currentTurnId,
+            state: session.turnState,
+            queueDepth: session.queue.length,
+            currentSpeakerId: agentId,
+            lastAcceptedIntent: session.lastAcceptedIntent,
+            capabilities: CODEX_RUNTIME_CAPABILITIES,
+            ...(session.currentTurnOpenedAt ? { openedAt: session.currentTurnOpenedAt } : {}),
+            ...(session.turnState === 'idle' || session.turnState === 'completed' || session.turnState === 'interrupted'
+                ? { completedAt: { '.sv': 'timestamp' } }
+                : {}),
+        }).catch(() => { });
+    }
+    async function markQueuedMessageAccepted(conversationId, sourceMessageId, markAccepted) {
+        if (!markAccepted || !sourceMessageId)
+            return;
+        await client.updateMessageDisposition(conversationId, sourceMessageId, 'accepted_now').catch(() => { });
+    }
     function clearStreaming(conversationId) {
         rtdbWrite(`/streaming/${conversationId}/${agentId}`, null).catch(() => { });
     }
@@ -170,6 +306,7 @@ async function main() {
         session.closed = true;
         clearStreaming(conversationId);
         clearSessionState(conversationId, agentId).catch(() => { });
+        clearTurnState(conversationId, agentId).catch(() => { });
         client.setTyping(conversationId, false).catch(() => { });
         sessions.delete(conversationId);
     }
@@ -227,11 +364,16 @@ async function main() {
                     model: sessionModel,
                     state: 'idle',
                 },
+                turnState: 'idle',
+                currentTurnId: null,
+                currentTurnOpenedAt: null,
+                lastAcceptedIntent: null,
                 lastActivity: Date.now(),
                 closed: false,
             };
             sessions.set(conversationId, session);
             writeState(session);
+            writeTurn(session);
             return session;
         })();
         pendingSessionCreations.set(conversationId, creation);
@@ -242,32 +384,68 @@ async function main() {
             pendingSessionCreations.delete(conversationId);
         }
     }
-    function enqueuePrompt(session, prompt) {
-        session.queue.push(prompt);
+    function enqueuePrompt(session, prompt, intent = 'queue', toFront = false, sourceMessageId, markAccepted = false) {
+        const nextPrompt = { prompt, intent, sourceMessageId, markAccepted };
+        if (toFront) {
+            session.queue.unshift(nextPrompt);
+        }
+        else {
+            session.queue.push(nextPrompt);
+        }
         session.lastActivity = Date.now();
+        writeTurn(session);
         void runNextTurn(session);
     }
     async function enqueueInboundMessage(input) {
         const content = renderInboundContent(input.message);
-        console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Message from ${input.senderName}: "${content.slice(0, 80)}"`);
+        const participantContext = await loadParticipantContext({
+            conversationId: input.conversationId,
+            message: input.message,
+            senderName: input.senderName,
+            isOwner: input.isOwner,
+        });
+        const autoReply = decideAutoReply(participantContext);
+        if (!autoReply.allow) {
+            console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Suppressed auto-reply: ${autoReply.reason}`);
+            return;
+        }
+        console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Message from ${input.senderName}: "${content.slice(0, 80)}" (${autoReply.reason})`);
         const session = await getOrCreateSession(input.conversationId);
-        enqueuePrompt(session, buildCanonPrompt({
+        const turnMetadata = normalizeTurnMetadata(input.message.metadata);
+        const deliveryIntent = turnMetadata?.deliveryIntent ?? 'queue';
+        const shouldMarkAccepted = turnMetadata?.inboundDisposition === 'queued';
+        const prompt = buildCanonPrompt({
             content,
             conversationId: input.conversationId,
-            isOwner: input.isOwner,
-            senderName: input.senderName,
-        }));
+            participantContext,
+        });
+        if (session.running && deliveryIntent === 'interrupt') {
+            enqueuePrompt(session, prompt, deliveryIntent, true, input.message.id, shouldMarkAccepted);
+            console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Interrupting current turn for explicit human send-now`);
+            await session.adapter.interrupt().catch(() => { });
+            clearStreaming(input.conversationId);
+            client.setTyping(input.conversationId, false).catch(() => { });
+            return;
+        }
+        enqueuePrompt(session, prompt, deliveryIntent, false, input.message.id, shouldMarkAccepted);
     }
     async function runNextTurn(session) {
         if (session.running || session.closed)
             return;
-        const prompt = session.queue.shift();
-        if (!prompt)
+        const nextTurn = session.queue.shift();
+        if (!nextTurn)
             return;
         session.running = true;
+        session.state.lastError = undefined;
         session.state.state = 'running';
+        session.currentTurnId = randomUUID();
+        session.currentTurnOpenedAt = Date.now();
+        session.lastAcceptedIntent = nextTurn.intent;
+        session.turnState = 'thinking';
         session.lastActivity = Date.now();
+        await markQueuedMessageAccepted(session.conversationId, nextTurn.sourceMessageId, nextTurn.markAccepted);
         writeState(session);
+        writeTurn(session);
         client.setTyping(session.conversationId, true, 'thinking').catch(() => { });
         rtdbWrite(`/streaming/${session.conversationId}/${agentId}`, {
             text: 'Thinking…',
@@ -275,7 +453,7 @@ async function main() {
             updatedAt: { '.sv': 'timestamp' },
         }).catch(() => { });
         try {
-            const result = await session.adapter.runTurn(prompt, (event) => {
+            const result = await session.adapter.runTurn(nextTurn.prompt, (event) => {
                 session.lastActivity = Date.now();
                 if (event.type === 'thread.started') {
                     saveStoredThreadId(agentId, session.conversationId, session.cwd, event.threadId);
@@ -283,6 +461,8 @@ async function main() {
                     return;
                 }
                 if (event.type === 'message') {
+                    session.turnState = 'streaming';
+                    writeTurn(session);
                     rtdbWrite(`/streaming/${session.conversationId}/${agentId}`, {
                         text: event.text,
                         status: 'streaming',
@@ -291,6 +471,8 @@ async function main() {
                     return;
                 }
                 if (event.type === 'command.started') {
+                    session.turnState = 'tool';
+                    writeTurn(session);
                     client.setTyping(session.conversationId, false).catch(() => { });
                     rtdbWrite(`/streaming/${session.conversationId}/${agentId}`, {
                         text: summarizeCommand(event.command),
@@ -300,6 +482,8 @@ async function main() {
                     return;
                 }
                 if (event.type === 'turn.completed') {
+                    session.turnState = 'completed';
+                    writeTurn(session);
                     writeState(session);
                 }
             }, (line) => {
@@ -311,31 +495,71 @@ async function main() {
             clearStreaming(session.conversationId);
             client.setTyping(session.conversationId, false).catch(() => { });
             if (!result.interrupted && result.finalMessage) {
-                await client.sendMessage(session.conversationId, result.finalMessage);
+                session.turnState = 'completed';
+                writeTurn(session);
+                await client.sendMessage(session.conversationId, result.finalMessage, {
+                    metadata: {
+                        turnId: session.currentTurnId,
+                        turnSemantics: 'turn_complete',
+                        turnComplete: true,
+                        deliveryIntent: session.lastAcceptedIntent ?? undefined,
+                    },
+                });
                 console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Sent reply (${result.finalMessage.length} chars)`);
             }
             else if (!result.interrupted && result.exitCode && result.exitCode !== 0) {
+                const userVisibleError = formatTurnFailure(result.errorText);
+                session.state.lastError = userVisibleError;
+                session.turnState = 'completed';
+                writeState(session);
+                writeTurn(session);
                 if (result.errorText) {
                     console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn exited ${result.exitCode}: ${result.errorText}`);
                 }
-                await client.sendMessage(session.conversationId, 'The Codex session stopped unexpectedly before sending a final reply.');
+                await client.sendMessage(session.conversationId, userVisibleError, {
+                    metadata: {
+                        turnId: session.currentTurnId,
+                        turnSemantics: 'turn_complete',
+                        turnComplete: true,
+                        deliveryIntent: session.lastAcceptedIntent ?? undefined,
+                    },
+                });
             }
             else if (result.interrupted) {
+                session.turnState = 'interrupted';
+                writeTurn(session);
                 console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn interrupted`);
             }
         }
         catch (error) {
             clearStreaming(session.conversationId);
             client.setTyping(session.conversationId, false).catch(() => { });
-            await client.sendMessage(session.conversationId, `The Codex host failed to start a turn: ${error instanceof Error ? error.message : String(error)}`).catch(() => { });
+            const message = `The Codex host failed to start a turn: ${error instanceof Error ? error.message : String(error)}`;
+            session.state.lastError = message;
+            session.turnState = 'completed';
+            writeState(session);
+            writeTurn(session);
+            await client.sendMessage(session.conversationId, message, {
+                metadata: {
+                    turnId: session.currentTurnId,
+                    turnSemantics: 'turn_complete',
+                    turnComplete: true,
+                    deliveryIntent: session.lastAcceptedIntent ?? undefined,
+                },
+            }).catch(() => { });
             clearStoredThreadId(agentId, session.conversationId);
             console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn failed:`, error);
         }
         finally {
             session.running = false;
             session.state.state = 'idle';
+            session.turnState = 'idle';
+            session.currentTurnId = null;
+            session.currentTurnOpenedAt = null;
+            session.lastAcceptedIntent = null;
             session.lastActivity = Date.now();
             writeState(session);
+            writeTurn(session);
             if (session.queue.length > 0) {
                 void runNextTurn(session);
             }
@@ -376,6 +600,7 @@ async function main() {
         for (const conversation of conversations) {
             clearStreaming(conversation.id);
             clearSessionState(conversation.id, agentId).catch(() => { });
+            clearTurnState(conversation.id, agentId).catch(() => { });
         }
         for (const conversation of conversations) {
             if (!conversation.lastMessage || conversation.lastMessage.senderId === agentId)
@@ -384,6 +609,18 @@ async function main() {
             const latestMessage = latestMessages[0];
             if (!latestMessage || latestMessage.senderId === agentId)
                 continue;
+            const senderTurnState = latestMessage.senderType === 'ai_agent'
+                ? await loadSenderRuntimeState(conversation.id, latestMessage.senderId)
+                : null;
+            const triggerDecision = shouldTriggerAgentTurn({
+                senderType: latestMessage.senderType ?? 'human',
+                metadata: latestMessage.metadata,
+                senderTurnState,
+            });
+            if (!triggerDecision.allow) {
+                console.error(`[canon-codex] [${conversation.id.slice(0, 8)}] Skipping startup recovery for suppressed message (${triggerDecision.reason})`);
+                continue;
+            }
             console.error(`[canon-codex] [${conversation.id.slice(0, 8)}] Recovering latest inbound message on startup`);
             await enqueueInboundMessage({
                 conversationId: conversation.id,
@@ -434,16 +671,21 @@ async function main() {
                         continue;
                     const signal = raw;
                     const timestamp = signal.updatedAt ?? 0;
-                    if (signal.type !== 'interrupt' || timestamp <= (lastSeenSignal.get(conversationId) ?? 0)) {
+                    if ((signal.type !== 'interrupt' && signal.type !== 'stop_and_drop')
+                        || timestamp <= (lastSeenSignal.get(conversationId) ?? 0)) {
                         continue;
                     }
                     lastSeenSignal.set(conversationId, timestamp);
                     const session = sessions.get(conversationId);
                     if (!session || session.closed)
                         continue;
-                    console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Interrupt signal`);
+                    console.error(`[canon-codex] [${conversationId.slice(0, 8)}] ${signal.type} signal`);
                     await session.adapter.interrupt();
-                    session.queue.length = 0;
+                    session.turnState = 'interrupted';
+                    if (signal.type === 'stop_and_drop') {
+                        session.queue.length = 0;
+                    }
+                    writeTurn(session);
                     clearStreaming(conversationId);
                     client.setTyping(conversationId, false).catch(() => { });
                 }
@@ -458,6 +700,7 @@ async function main() {
     const heartbeat = setInterval(() => {
         for (const session of sessions.values()) {
             writeState(session);
+            writeTurn(session);
         }
     }, HEARTBEAT_MS);
     const idleCheck = setInterval(() => {

package/dist/inbound-policy.d.ts

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

package/dist/inbound-policy.js

@@ -0,0 +1,50 @@
+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}`,
+        `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}`,
+    ];
+}
+export function decideAutoReply(context) {
+    if (context.senderType !== 'ai_agent') {
+        return { allow: true, reason: 'latest sender is human' };
+    }
+    if (context.isOwner) {
+        return { allow: true, reason: 'owner messages always pass through' };
+    }
+    if (context.mentionedAgent) {
+        return { allow: true, reason: 'another agent explicitly addressed this agent' };
+    }
+    if (context.conversationType === 'group') {
+        return {
+            allow: false,
+            reason: 'suppressing group agent auto-reply without a direct mention',
+        };
+    }
+    if (context.consecutiveAgentTurns >= 2 && context.recentHumanCount === 0) {
+        return {
+            allow: false,
+            reason: 'suppressing likely agent-only loop in a direct conversation',
+        };
+    }
+    return { allow: true, reason: 'direct agent message allowed' };
+}

package/dist/setup.js

@@ -11,6 +11,9 @@ else {
     console.log('Install Codex first, then rerun this setup.\n');
 }
 console.log('Next steps:');
+console.log('  0. Confirm Codex is logged in the way you want Canon to use');
+console.log('     codex login status');
+console.log('');
 console.log('  1. Register your agent');
 console.log('     canon-codex-register --name "My Codex" --description "My local coding agent" --phone "+15551234567"');
 console.log('');
@@ -20,5 +23,7 @@ console.log('');
 console.log('Optional flags:');
 console.log('  --model gpt-5.4');
 console.log('  --sandbox workspace-write');
-console.log('  --ask-for-approval never');
 console.log('  --full-auto');
+console.log('');
+console.log('Note: recent Codex CLI versions use --full-auto for non-interactive write access.');
+console.log('Note: Canon uses the local Codex login state by default (for example ChatGPT/device auth or API-key auth).');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/host.js",
@@ -11,15 +11,18 @@
     "canon-codex-setup": "dist/setup.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "scripts"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
     "dev": "tsc --watch",
-    "prepublishOnly": "npm run build"
+    "smoke": "node scripts/smoke-test.mjs",
+    "test": "vitest run",
+    "prepack": "npm run build"
   },
   "dependencies": {
-    "@canonmsg/core": "^0.2.2"
+    "@canonmsg/core": "^0.3.0"
   },
   "engines": {
     "node": ">=18.0.0"
@@ -42,7 +45,8 @@
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
-    "typescript": "~5.7.0"
+    "typescript": "~5.7.0",
+    "vitest": "^3.0.0"
   },
   "license": "MIT"
 }

package/scripts/smoke-test.mjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+import { spawn } from 'node:child_process';
+import { resolve } from 'node:path';
+
+const targetCwd = resolve(process.argv[2] || process.cwd());
+const prompt = 'Reply with exactly OK.';
+
+function run(command, args) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn(command, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk.toString();
+    });
+
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk.toString();
+    });
+
+    child.on('error', rejectPromise);
+    child.on('close', (code) => {
+      resolvePromise({ code, stdout, stderr });
+    });
+  });
+}
+
+function parseJsonLines(text) {
+  return text
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith('{'))
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+const version = await run('codex', ['--version']);
+if (version.code !== 0) {
+  console.error('codex --version failed');
+  process.exit(version.code ?? 1);
+}
+
+console.log(version.stdout.trim());
+console.log(`Workspace: ${targetCwd}`);
+
+const result = await run('codex', [
+  'exec',
+  '--json',
+  '--color',
+  'never',
+  '-C',
+  targetCwd,
+  '--skip-git-repo-check',
+  prompt,
+]);
+
+const events = parseJsonLines(result.stdout);
+const threadStarted = events.find((event) => event?.type === 'thread.started');
+const turnFailed = events.find((event) => event?.type === 'turn.failed');
+const messageEvent = [...events].reverse().find(
+  (event) => event?.type === 'item.completed' && event?.item?.type === 'agent_message',
+);
+
+if (threadStarted) {
+  console.log(`Thread started: ${threadStarted.thread_id}`);
+}
+
+if (messageEvent?.item?.text) {
+  console.log(`Final message: ${String(messageEvent.item.text).trim()}`);
+}
+
+if (turnFailed?.error?.message) {
+  console.error(`Turn failed: ${turnFailed.error.message}`);
+}
+
+if (result.stderr.trim()) {
+  console.error('stderr:');
+  console.error(result.stderr.trim());
+}
+
+process.exit(result.code ?? 1);