@canonmsg/codex-plugin 0.1.1 → 0.3.0

package/README.md

@@ -16,10 +16,14 @@ codex login status
 # Register (approve in Canon when prompted)
 canon-codex-register --name "My Codex" --description "My local coding agent" --phone "+15551234567"
 
-# Run inside a project
+# Run inside a project and keep the host process running
 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.
+
+You do not need a git repo for host mode. The plugin passes `--skip-git-repo-check` to Codex, so any readable working directory is valid.
+
 ## What v1 supports
 
 - Canon messages routed into Codex turns
@@ -55,6 +59,24 @@ npm run smoke -- /path/to/project
 
 ## Troubleshooting
 
+If Canon messages are not getting replies, first confirm the local host process is still running:
+
+```bash
+ps aux | rg canon-codex
+```
+
+If you installed the package only inside this repo and not globally, run the built host directly:
+
+```bash
+node packages/codex-plugin/dist/host.js --cwd /path/to/project --full-auto
+```
+
+If Canon rejects authenticated requests with `401 Invalid API key`, the stored Canon profile needs a fresh key. Rerun registration for the same profile to overwrite `~/.canon/agents.json`, then restart the host:
+
+```bash
+canon-codex-register --name "My Codex" --description "My local coding agent" --phone "+15551234567" --profile my-codex
+```
+
 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

package/dist/host.js

@@ -1,9 +1,9 @@
 #!/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 { buildParticipationHistorySnapshot, buildBehaviorPolicyLines, buildConfiguredWorkspaceOptions, buildPublicWorkspaceOptions, ExecutionEnvironmentError, isEnabledFlag, readSessionWorkspaceConfig, resolveConfiguredWorkspaceCwd, CanonClient, CanonStream, clearSessionState, clearTurnState, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, FINAL_MESSAGE_HANDOFF_MS, getActiveProfile, initRTDBAuth, normalizeTurnMetadata, normalizeTurnState, prepareConversationEnvironment, releaseLock, releaseConversationEnvironment, 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';
@@ -12,27 +12,29 @@ 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: false,
+};
 let workingDir = process.cwd();
 let workspaceOptions = [];
-function normalizeString(value) {
-    if (typeof value !== 'string')
-        return undefined;
-    const trimmed = value.trim();
-    return trimmed ? trimmed : undefined;
-}
-function buildWorkspaceOptions(primaryCwd, configured) {
-    const uniqueDirs = Array.from(new Set([primaryCwd, ...configured].map((dir) => resolve(dir))));
-    const seenLabels = new Map();
-    return uniqueDirs.map((cwd, index) => {
-        const baseLabel = basename(cwd) || cwd;
-        const seenCount = (seenLabels.get(baseLabel) ?? 0) + 1;
-        seenLabels.set(baseLabel, seenCount);
-        return {
-            id: index === 0 ? 'default' : `workspace-${index + 1}`,
-            label: seenCount === 1 ? baseLabel : `${baseLabel} (${seenCount})`,
-            cwd,
-        };
-    });
+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;
 }
 async function publishAgentRuntime(agentId, runtime) {
     await rtdbWrite(`/agent-runtime/${agentId}`, {
@@ -44,40 +46,24 @@ async function publishAgentRuntime(agentId, runtime) {
 }
 async function loadSessionConfig(conversationId, agentId) {
     const raw = await rtdbRead(`/session-config/${conversationId}/${agentId}`);
-    if (!raw || typeof raw !== 'object')
-        return null;
-    const data = raw;
-    return {
-        workspaceId: normalizeString(data.workspaceId),
-        legacyCwd: normalizeString(data.cwd),
-        model: normalizeString(data.model),
-    };
+    return readSessionWorkspaceConfig(raw);
 }
 function resolveWorkspaceCwd(config) {
-    if (config?.workspaceId) {
-        const workspace = workspaceOptions.find((option) => option.id === config.workspaceId);
-        if (workspace)
-            return workspace.cwd;
-    }
-    if (config?.legacyCwd) {
-        const workspace = workspaceOptions.find((option) => option.cwd === config.legacyCwd);
-        if (workspace)
-            return workspace.cwd;
-    }
-    return workspaceOptions[0]?.cwd ?? workingDir;
-}
-function toPublicWorkspaceOptions() {
-    return workspaceOptions.map(({ id, label }) => ({ id, label }));
+    return resolveConfiguredWorkspaceCwd({
+        workspaceOptions,
+        config,
+        defaultCwd: workingDir,
+    });
 }
 function buildCanonPrompt(input) {
     return [
         'You are connected to Canon messaging through a Codex host wrapper.',
-        '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.',
         ...buildInboundContextLines(input.participantContext),
+        ...buildBehaviorPolicyLines(input.behavior),
         '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.',
+        'Honor the Canon behavior policy above when deciding how proactively to participate.',
         `Conversation ID: ${input.conversationId}`,
         '',
         'New Canon message:',
@@ -132,6 +118,9 @@ function formatTurnFailure(errorText) {
     const shortened = normalized.length > 280 ? `${normalized.slice(0, 277)}...` : normalized;
     return `Codex failed before sending a final reply: ${shortened}`;
 }
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 async function main() {
     const { values: args } = parseArgs({
         options: {
@@ -145,12 +134,17 @@ async function main() {
             config: { type: 'string', multiple: true },
             'codex-bin': { type: 'string' },
             'full-auto': { type: 'boolean' },
+            'enable-worktrees': { type: 'boolean' },
             'dangerously-bypass-approvals-and-sandbox': { type: 'boolean' },
         },
         strict: true,
     });
     workingDir = (typeof args.cwd === 'string' ? args.cwd : null) || process.cwd();
-    workspaceOptions = buildWorkspaceOptions(workingDir, args.workspace ?? []);
+    workspaceOptions = buildConfiguredWorkspaceOptions(workingDir, args.workspace ?? []);
+    const allowWorktrees = isEnabledFlag(args['enable-worktrees'] ?? process.env.CANON_ENABLE_WORKTREES);
+    if (!allowWorktrees) {
+        console.error('[canon-codex] Worktree isolation is disabled; sessions will lock their selected workspace unless explicitly enabled.');
+    }
     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.');
     }
@@ -204,20 +198,24 @@ async function main() {
             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(() => []),
+            client.getMessages(input.conversationId, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT).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;
-        }
+        const history = buildParticipationHistorySnapshot(recentMessages, agentId);
         return {
             conversationType: conversation?.type ?? 'unknown',
             memberCount: conversation?.memberIds?.length ?? null,
@@ -225,10 +223,11 @@ async function main() {
             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,
+            recentSenderTypes: history.recentSenderTypes,
+            recentHumanCount: history.recentHumanCount,
+            recentAgentCount: history.recentAgentCount,
+            consecutiveAgentTurns: history.consecutiveAgentTurns,
+            currentAgentStreakStartedByHuman: history.currentAgentStreakStartedByHuman,
         };
     }
     function writeState(session) {
@@ -236,22 +235,50 @@ async function main() {
             lastError: session.state.lastError,
             model: session.state.model,
             cwd: session.cwd,
+            executionMode: session.environment.mode,
+            ...(session.environment.branch ? { executionBranch: session.environment.branch } : {}),
             hostMode: true,
             clientType: 'codex',
             state: session.state.state,
             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(() => { });
     }
+    async function handoffFinalMessage(conversationId) {
+        await sleep(FINAL_MESSAGE_HANDOFF_MS);
+        clearStreaming(conversationId);
+        client.setTyping(conversationId, false).catch(() => { });
+    }
     function closeSession(conversationId) {
         const session = sessions.get(conversationId);
         if (!session)
             return;
         session.closed = true;
+        releaseConversationEnvironment(session.environment);
         clearStreaming(conversationId);
         clearSessionState(conversationId, agentId).catch(() => { });
+        clearTurnState(conversationId, agentId).catch(() => { });
         client.setTyping(conversationId, false).catch(() => { });
         sessions.delete(conversationId);
     }
@@ -282,39 +309,59 @@ async function main() {
         }
         const creation = (async () => {
             const config = await loadSessionConfig(conversationId, agentId);
-            const sessionCwd = resolveWorkspaceCwd(config);
-            const sessionModel = config?.model ?? (typeof args.model === 'string' ? args.model : undefined);
-            const storedThreadId = loadStoredThreadId(agentId, conversationId, sessionCwd);
-            const session = {
+            const workspaceCwd = resolveWorkspaceCwd(config);
+            const environment = prepareConversationEnvironment({
+                agentId,
                 conversationId,
-                cwd: sessionCwd,
-                adapter: new CodexConversationAdapter({
+                workspaceCwd,
+                allowWorktrees,
+            });
+            try {
+                const sessionCwd = environment.cwd;
+                const sessionModel = config?.model ?? (typeof args.model === 'string' ? args.model : undefined);
+                const storedThreadId = loadStoredThreadId(agentId, conversationId, sessionCwd);
+                const session = {
+                    conversationId,
                     cwd: sessionCwd,
-                    threadId: storedThreadId,
-                    codexBin: typeof args['codex-bin'] === 'string' ? args['codex-bin'] : 'codex',
-                    model: sessionModel ?? null,
-                    sandbox: (typeof args.sandbox === 'string' ? args.sandbox : null),
-                    approvalPolicy: (typeof args['ask-for-approval'] === 'string'
-                        ? args['ask-for-approval']
-                        : null),
-                    codexProfile: typeof args['codex-profile'] === 'string' ? args['codex-profile'] : null,
-                    addDirs: args['add-dir'] ?? [],
-                    configOverrides: args.config ?? [],
-                    fullAuto: Boolean(args['full-auto']),
-                    bypassApprovalsAndSandbox: Boolean(args['dangerously-bypass-approvals-and-sandbox']),
-                }),
-                queue: [],
-                running: false,
-                state: {
-                    model: sessionModel,
-                    state: 'idle',
-                },
-                lastActivity: Date.now(),
-                closed: false,
-            };
-            sessions.set(conversationId, session);
-            writeState(session);
-            return session;
+                    environment,
+                    adapter: new CodexConversationAdapter({
+                        cwd: sessionCwd,
+                        threadId: storedThreadId,
+                        codexBin: typeof args['codex-bin'] === 'string' ? args['codex-bin'] : 'codex',
+                        model: sessionModel ?? null,
+                        sandbox: (typeof args.sandbox === 'string' ? args.sandbox : null),
+                        approvalPolicy: (typeof args['ask-for-approval'] === 'string'
+                            ? args['ask-for-approval']
+                            : null),
+                        codexProfile: typeof args['codex-profile'] === 'string' ? args['codex-profile'] : null,
+                        addDirs: args['add-dir'] ?? [],
+                        configOverrides: args.config ?? [],
+                        fullAuto: Boolean(args['full-auto']),
+                        bypassApprovalsAndSandbox: Boolean(args['dangerously-bypass-approvals-and-sandbox']),
+                    }),
+                    queue: [],
+                    running: false,
+                    state: {
+                        model: sessionModel,
+                        state: 'idle',
+                    },
+                    turnState: 'idle',
+                    currentTurnId: null,
+                    currentTurnOpenedAt: null,
+                    lastAcceptedIntent: null,
+                    lastActivity: Date.now(),
+                    closed: false,
+                };
+                sessions.set(conversationId, session);
+                console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Environment → ${environment.mode} (${sessionCwd})`);
+                writeState(session);
+                writeTurn(session);
+                return session;
+            }
+            catch (error) {
+                releaseConversationEnvironment(environment);
+                throw error;
+            }
         })();
         pendingSessionCreations.set(conversationId, creation);
         try {
@@ -324,43 +371,81 @@ 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);
+        const conversation = await getConversationMeta(input.conversationId);
+        const behavior = input.behavior ?? conversation?.behavior;
         const participantContext = await loadParticipantContext({
             conversationId: input.conversationId,
             message: input.message,
             senderName: input.senderName,
             isOwner: input.isOwner,
         });
-        const autoReply = decideAutoReply(participantContext);
+        const autoReply = decideAutoReply(participantContext, behavior);
         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({
+        let session;
+        try {
+            session = await getOrCreateSession(input.conversationId);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const userMessage = error instanceof ExecutionEnvironmentError ? error.userMessage : message;
+            console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Failed to create session: ${message}`);
+            await client.sendMessage(input.conversationId, `I couldn't start a coding session for this workspace: ${userMessage}`).catch(() => { });
+            return;
+        }
+        const turnMetadata = normalizeTurnMetadata(input.message.metadata);
+        const deliveryIntent = turnMetadata?.deliveryIntent ?? 'queue';
+        const shouldMarkAccepted = turnMetadata?.inboundDisposition === 'queued';
+        const prompt = buildCanonPrompt({
             content,
             conversationId: input.conversationId,
             participantContext,
-        }));
+            behavior,
+        });
+        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…',
@@ -368,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);
@@ -376,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',
@@ -384,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),
@@ -401,10 +490,16 @@ async function main() {
             if (result.threadId) {
                 saveStoredThreadId(agentId, session.conversationId, session.cwd, result.threadId);
             }
-            clearStreaming(session.conversationId);
-            client.setTyping(session.conversationId, false).catch(() => { });
             if (!result.interrupted && result.finalMessage) {
-                await client.sendMessage(session.conversationId, result.finalMessage);
+                await client.sendMessage(session.conversationId, result.finalMessage, {
+                    metadata: {
+                        turnId: session.currentTurnId,
+                        turnSemantics: 'turn_complete',
+                        turnComplete: true,
+                        deliveryIntent: session.lastAcceptedIntent ?? undefined,
+                    },
+                });
+                await handoffFinalMessage(session.conversationId);
                 console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Sent reply (${result.finalMessage.length} chars)`);
             }
             else if (!result.interrupted && result.exitCode && result.exitCode !== 0) {
@@ -414,27 +509,53 @@ async function main() {
                 if (result.errorText) {
                     console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn exited ${result.exitCode}: ${result.errorText}`);
                 }
-                await client.sendMessage(session.conversationId, userVisibleError);
+                await client.sendMessage(session.conversationId, userVisibleError, {
+                    metadata: {
+                        turnId: session.currentTurnId,
+                        turnSemantics: 'turn_complete',
+                        turnComplete: true,
+                        deliveryIntent: session.lastAcceptedIntent ?? undefined,
+                    },
+                });
+                await handoffFinalMessage(session.conversationId);
+            }
+            else if (!result.interrupted) {
+                await handoffFinalMessage(session.conversationId);
             }
             else if (result.interrupted) {
+                session.turnState = 'interrupted';
+                writeTurn(session);
+                clearStreaming(session.conversationId);
+                client.setTyping(session.conversationId, false).catch(() => { });
                 console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn interrupted`);
             }
         }
         catch (error) {
-            clearStreaming(session.conversationId);
-            client.setTyping(session.conversationId, false).catch(() => { });
             const message = `The Codex host failed to start a turn: ${error instanceof Error ? error.message : String(error)}`;
             session.state.lastError = message;
             writeState(session);
-            await client.sendMessage(session.conversationId, message).catch(() => { });
+            await client.sendMessage(session.conversationId, message, {
+                metadata: {
+                    turnId: session.currentTurnId,
+                    turnSemantics: 'turn_complete',
+                    turnComplete: true,
+                    deliveryIntent: session.lastAcceptedIntent ?? undefined,
+                },
+            }).catch(() => { });
+            await handoffFinalMessage(session.conversationId);
             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);
             }
@@ -452,7 +573,8 @@ async function main() {
                     conversationId: payload.conversationId,
                     message,
                     senderName: message.senderName || message.senderId,
-                    isOwner: Boolean(message.isOwner),
+                    isOwner: message.isOwner ?? (ownerId != null && message.senderId === ownerId),
+                    behavior: payload.behavior,
                 });
             },
             onConnected: () => console.error('[canon-codex] SSE connected'),
@@ -464,7 +586,7 @@ async function main() {
         await publishAgentRuntime(agentId, {
             defaultWorkspaceId: workspaceOptions[0]?.id,
             ...(typeof args.model === 'string' ? { defaultModel: args.model } : {}),
-            availableWorkspaces: toPublicWorkspaceOptions(),
+            availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
         });
     }
     catch (error) {
@@ -475,20 +597,34 @@ 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)
                 continue;
-            const latestMessages = await client.getMessages(conversation.id, 1);
-            const latestMessage = latestMessages[0];
+            const latestPage = await client.getMessagesPage(conversation.id, 1);
+            const latestMessage = latestPage.messages[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,
                 message: latestMessage,
                 senderName: latestMessage.senderId,
                 isOwner: ownerId != null && latestMessage.senderId === ownerId,
+                behavior: latestPage.behavior,
             });
         }
     }
@@ -533,16 +669,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(() => { });
                 }
@@ -557,6 +698,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

@@ -1,4 +1,4 @@
-import type { CanonConversation } from '@canonmsg/core';
+import { type CanonConversation, type ResolvedAgentBehaviorPolicy } from '@canonmsg/core';
 export interface InboundParticipantContext {
     conversationType: CanonConversation['type'] | 'unknown';
     memberCount: number | null;
@@ -10,10 +10,11 @@ export interface InboundParticipantContext {
     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): AutoReplyDecision;
+export declare function decideAutoReply(context: InboundParticipantContext, behavior?: ResolvedAgentBehaviorPolicy | null): AutoReplyDecision;

package/dist/inbound-policy.js

@@ -1,3 +1,4 @@
+import { evaluateParticipationPolicy, resolveAgentBehaviorPolicy, } from '@canonmsg/core';
 function formatRecentSenders(senderTypes) {
     if (senderTypes.length === 0)
         return 'none';
@@ -22,29 +23,21 @@ export function buildInboundContextLines(context) {
         `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) {
-    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' && context.recentHumanCount === 0) {
-        return {
-            allow: false,
-            reason: 'suppressing agent-only group 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' };
+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/setup.js

@@ -17,9 +17,11 @@ 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('');
-console.log('  2. Start the host in a project directory');
+console.log('  2. Start the host in a project directory and keep it running');
 console.log('     canon-codex --cwd /path/to/project');
 console.log('');
+console.log('     A git repo is not required; any readable directory works.');
+console.log('');
 console.log('Optional flags:');
 console.log('  --model gpt-5.4');
 console.log('  --sandbox workspace-write');
@@ -27,3 +29,4 @@ 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).');
+console.log('Note: If Canon starts returning "Invalid API key", rerun canon-codex-register to replace the saved profile and then restart the host.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/host.js",
@@ -15,14 +15,14 @@
     "scripts"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
     "dev": "tsc --watch",
     "smoke": "node scripts/smoke-test.mjs",
     "test": "vitest run",
-    "prepublishOnly": "npm run build"
+    "prepack": "npm run build"
   },
   "dependencies": {
-    "@canonmsg/core": "^0.2.2"
+    "@canonmsg/core": "^0.4.0"
   },
   "engines": {
     "node": ">=18.0.0"

package/dist/adapter.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/adapter.test.js

@@ -1,59 +0,0 @@
-import { EventEmitter } from 'node:events';
-import { PassThrough } from 'node:stream';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const { spawnMock } = vi.hoisted(() => ({
-    spawnMock: vi.fn(),
-}));
-vi.mock('node:child_process', () => ({
-    spawn: spawnMock,
-}));
-import { CodexConversationAdapter } from './adapter.js';
-class MockChildProcess extends EventEmitter {
-    stdout = new PassThrough();
-    stderr = new PassThrough();
-}
-describe('CodexConversationAdapter', () => {
-    beforeEach(() => {
-        spawnMock.mockReset();
-    });
-    it('translates legacy non-interactive approval flags into --full-auto', () => {
-        const adapter = new CodexConversationAdapter({
-            cwd: '/tmp/project',
-            sandbox: 'workspace-write',
-            approvalPolicy: 'never',
-        });
-        const args = adapter.buildArgs('hello');
-        expect(args).toContain('--full-auto');
-        expect(args).not.toContain('-a');
-        expect(args).not.toContain('--ask-for-approval');
-    });
-    it('does not force --full-auto for read-only sessions', () => {
-        const adapter = new CodexConversationAdapter({
-            cwd: '/tmp/project',
-            sandbox: 'read-only',
-            approvalPolicy: 'never',
-        });
-        const args = adapter.buildArgs('hello');
-        expect(args).toContain('-s');
-        expect(args).toContain('read-only');
-        expect(args).not.toContain('--full-auto');
-    });
-    it('preserves structured turn failure text from Codex JSON output', async () => {
-        const child = new MockChildProcess();
-        spawnMock.mockReturnValue(child);
-        const adapter = new CodexConversationAdapter({
-            cwd: '/tmp/project',
-        });
-        const turnPromise = adapter.runTurn('hello', () => { });
-        child.stdout.write('{"type":"thread.started","thread_id":"thread-123"}\n');
-        child.stdout.write('{"type":"turn.started"}\n');
-        child.stdout.write('{"type":"error","message":"Quota exceeded. Check your plan and billing details."}\n');
-        child.stdout.write('{"type":"turn.failed","error":{"message":"Quota exceeded. Check your plan and billing details."}}\n');
-        child.emit('close', 1);
-        const result = await turnPromise;
-        expect(result.threadId).toBe('thread-123');
-        expect(result.exitCode).toBe(1);
-        expect(result.finalMessage).toBeNull();
-        expect(result.errorText).toBe('Quota exceeded. Check your plan and billing details.');
-    });
-});

package/dist/inbound-policy.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/inbound-policy.test.js

@@ -1,97 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildInboundContextLines, decideAutoReply } from './inbound-policy.js';
-function makeContext(overrides = {}) {
-    return {
-        conversationType: 'direct',
-        memberCount: 2,
-        senderType: 'human',
-        senderName: 'Alice',
-        isOwner: false,
-        mentionedAgent: false,
-        recentSenderTypes: ['human'],
-        recentHumanCount: 1,
-        recentAgentCount: 0,
-        consecutiveAgentTurns: 0,
-        ...overrides,
-    };
-}
-describe('decideAutoReply', () => {
-    it('allows human senders', () => {
-        const decision = decideAutoReply(makeContext());
-        expect(decision).toEqual({
-            allow: true,
-            reason: 'latest sender is human',
-        });
-    });
-    it('suppresses group messages from another agent without a mention', () => {
-        const decision = decideAutoReply(makeContext({
-            conversationType: 'group',
-            memberCount: 3,
-            senderType: 'ai_agent',
-            recentSenderTypes: ['ai_agent', 'ai_agent'],
-            recentHumanCount: 0,
-            recentAgentCount: 2,
-            consecutiveAgentTurns: 2,
-        }));
-        expect(decision.allow).toBe(false);
-    });
-    it('allows group agent replies while a human is still active in the recent window', () => {
-        const decision = decideAutoReply(makeContext({
-            conversationType: 'group',
-            memberCount: 3,
-            senderType: 'ai_agent',
-            recentSenderTypes: ['ai_agent', 'human'],
-            recentHumanCount: 1,
-            recentAgentCount: 1,
-            consecutiveAgentTurns: 1,
-        }));
-        expect(decision).toEqual({
-            allow: true,
-            reason: 'direct agent message allowed',
-        });
-    });
-    it('allows explicitly addressed agent messages in groups', () => {
-        const decision = decideAutoReply(makeContext({
-            conversationType: 'group',
-            memberCount: 3,
-            senderType: 'ai_agent',
-            mentionedAgent: true,
-            recentSenderTypes: ['ai_agent', 'human'],
-            recentHumanCount: 1,
-            recentAgentCount: 1,
-            consecutiveAgentTurns: 1,
-        }));
-        expect(decision).toEqual({
-            allow: true,
-            reason: 'another agent explicitly addressed this agent',
-        });
-    });
-    it('suppresses likely direct agent loops with no recent human activity', () => {
-        const decision = decideAutoReply(makeContext({
-            senderType: 'ai_agent',
-            recentSenderTypes: ['ai_agent', 'ai_agent'],
-            recentHumanCount: 0,
-            recentAgentCount: 2,
-            consecutiveAgentTurns: 2,
-        }));
-        expect(decision.allow).toBe(false);
-    });
-});
-describe('buildInboundContextLines', () => {
-    it('includes sender and recent activity context', () => {
-        const lines = buildInboundContextLines(makeContext({
-            conversationType: 'group',
-            memberCount: 4,
-            senderType: 'ai_agent',
-            senderName: 'Ernest',
-            recentSenderTypes: ['ai_agent', 'human', 'ai_agent'],
-            recentHumanCount: 1,
-            recentAgentCount: 2,
-            consecutiveAgentTurns: 1,
-        }));
-        expect(lines).toContain('Latest sender name: Ernest');
-        expect(lines).toContain('Latest sender type: ai_agent');
-        expect(lines).toContain('Conversation type: group (4 members)');
-        expect(lines).toContain('Recent sender pattern: agent -> human -> agent');
-    });
-});