@canonmsg/codex-plugin 0.2.0 → 0.4.0

package/README.md

@@ -16,12 +16,16 @@ 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.
 
+If the terminal closes or the machine restarts, the agent goes offline until you start the host again. To bring back the same registered agent, rerun `canon-codex --cwd /path/to/project`. Do not run registration again unless Canon tells you the saved API key is invalid. If you registered multiple profiles, relaunch the same one with `CANON_AGENT=<profile> canon-codex --cwd /path/to/project`.
+
+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
@@ -57,6 +61,30 @@ 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-codex` starts but cannot find the `codex` binary, either fix your `PATH` or launch with an explicit binary path:
+
+```bash
+canon-codex --cwd /path/to/project --codex-bin /absolute/path/to/codex
+```
+
+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

@@ -3,8 +3,7 @@ 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, clearTurnState, DEFAULT_RUNTIME_CAPABILITIES, getActiveProfile, initRTDBAuth, normalizeTurnMetadata, normalizeTurnState, releaseLock, resolveCanonAgent, rtdbRead, rtdbWrite, shouldTriggerAgentTurn, writeSessionState, writeTurnState, } 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';
@@ -17,16 +16,10 @@ const CODEX_RUNTIME_CAPABILITIES = {
     ...DEFAULT_RUNTIME_CAPABILITIES,
     supportsInterrupt: true,
     supportsQueue: true,
-    supportsNonFinalPermanentMessages: 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 normalizeRuntimeTurnState(value) {
     const normalizedTurn = normalizeTurnState(value);
     if (normalizedTurn) {
@@ -43,20 +36,6 @@ function normalizeRuntimeTurnState(value) {
     }
     return null;
 }
-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,
-        };
-    });
-}
 async function publishAgentRuntime(agentId, runtime) {
     await rtdbWrite(`/agent-runtime/${agentId}`, {
         clientType: 'codex',
@@ -67,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:',
@@ -155,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: {
@@ -168,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.');
     }
@@ -242,17 +213,9 @@ async function main() {
     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,
@@ -260,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) {
@@ -271,6 +235,8 @@ 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,
@@ -299,11 +265,17 @@ async function main() {
     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(() => { });
@@ -337,44 +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',
-                },
-                turnState: 'idle',
-                currentTurnId: null,
-                currentTurnOpenedAt: null,
-                lastAcceptedIntent: null,
-                lastActivity: Date.now(),
-                closed: false,
-            };
-            sessions.set(conversationId, session);
-            writeState(session);
-            writeTurn(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 {
@@ -398,19 +385,31 @@ async function main() {
     }
     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);
+        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';
@@ -418,6 +417,7 @@ async function main() {
             content,
             conversationId: input.conversationId,
             participantContext,
+            behavior,
         });
         if (session.running && deliveryIntent === 'interrupt') {
             enqueuePrompt(session, prompt, deliveryIntent, true, input.message.id, shouldMarkAccepted);
@@ -482,8 +482,6 @@ async function main() {
                     return;
                 }
                 if (event.type === 'turn.completed') {
-                    session.turnState = 'completed';
-                    writeTurn(session);
                     writeState(session);
                 }
             }, (line) => {
@@ -492,11 +490,7 @@ 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) {
-                session.turnState = 'completed';
-                writeTurn(session);
                 await client.sendMessage(session.conversationId, result.finalMessage, {
                     metadata: {
                         turnId: session.currentTurnId,
@@ -505,14 +499,13 @@ async function main() {
                         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) {
                 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}`);
                 }
@@ -524,21 +517,23 @@ async function main() {
                         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;
-            session.turnState = 'completed';
             writeState(session);
-            writeTurn(session);
             await client.sendMessage(session.conversationId, message, {
                 metadata: {
                     turnId: session.currentTurnId,
@@ -547,6 +542,7 @@ async function main() {
                     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);
         }
@@ -565,6 +561,20 @@ async function main() {
             }
         }
     }
+    let controlStopped = false;
+    let streamConnected = false;
+    let runtimeDescriptor = {
+        defaultWorkspaceId: workspaceOptions[0]?.id,
+        ...(typeof args.model === 'string' ? { defaultModel: args.model } : {}),
+        availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
+    };
+    const publishRuntimeHeartbeat = async () => {
+        if (!streamConnected)
+            return;
+        await publishAgentRuntime(agentId, runtimeDescriptor).catch((error) => {
+            console.error('[canon-codex] Failed to publish agent runtime:', error);
+        });
+    };
     const stream = new CanonStream({
         apiKey,
         agentId,
@@ -577,23 +587,35 @@ 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'),
-            onDisconnected: () => console.error('[canon-codex] SSE disconnected'),
+            onConnected: () => {
+                streamConnected = true;
+                void publishRuntimeHeartbeat();
+                console.error('[canon-codex] SSE connected');
+            },
+            onDisconnected: () => {
+                streamConnected = false;
+                rtdbWrite(`/agent-runtime/${agentId}`, null).catch(() => { });
+                console.error('[canon-codex] SSE disconnected');
+            },
             onError: (error) => console.error(`[canon-codex] SSE error: ${error.message}`),
         },
     });
     try {
-        await publishAgentRuntime(agentId, {
+        runtimeDescriptor = {
             defaultWorkspaceId: workspaceOptions[0]?.id,
             ...(typeof args.model === 'string' ? { defaultModel: args.model } : {}),
-            availableWorkspaces: toPublicWorkspaceOptions(),
-        });
+            availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
+        };
     }
-    catch (error) {
-        console.error('[canon-codex] Failed to publish agent runtime:', error);
+    catch {
+        runtimeDescriptor = {
+            defaultWorkspaceId: workspaceOptions[0]?.id,
+            availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
+        };
     }
     try {
         const conversations = await client.getConversations();
@@ -605,8 +627,8 @@ async function main() {
         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'
@@ -627,6 +649,7 @@ async function main() {
                 message: latestMessage,
                 senderName: latestMessage.senderId,
                 isOwner: ownerId != null && latestMessage.senderId === ownerId,
+                behavior: latestPage.behavior,
             });
         }
     }
@@ -636,7 +659,6 @@ async function main() {
     await stream.start().catch((error) => {
         console.error('[canon-codex] SSE start error:', error instanceof Error ? error.message : error);
     });
-    let controlStopped = false;
     const lastSeenControl = new Map();
     const lastSeenSignal = new Map();
     const pollControl = async () => {
@@ -702,6 +724,7 @@ async function main() {
             writeState(session);
             writeTurn(session);
         }
+        void publishRuntimeHeartbeat();
     }, HEARTBEAT_MS);
     const idleCheck = setInterval(() => {
         const now = Date.now();
@@ -721,6 +744,7 @@ async function main() {
         clearInterval(heartbeat);
         clearInterval(idleCheck);
         stream.stop();
+        await rtdbWrite(`/agent-runtime/${agentId}`, null).catch(() => { });
         for (const session of [...sessions.values()]) {
             await session.adapter.interrupt().catch(() => { });
             closeSession(session.conversationId);

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') {
-        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' };
+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/register.js

@@ -23,6 +23,14 @@ if (!values.name || !values.description || !values.phone) {
     process.exit(1);
 }
 const profileName = values.profile || values.name.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
+let existingAgentId;
+try {
+    const profiles = JSON.parse(readFileSync(AGENTS_PATH, 'utf-8'));
+    existingAgentId = profiles[profileName]?.agentId;
+}
+catch {
+    // No existing profile state.
+}
 console.log(`Registering Codex agent "${values.name}" (profile: ${profileName})...`);
 const result = await registerAndWaitForApproval({
     name: values.name,
@@ -31,6 +39,7 @@ const result = await registerAndWaitForApproval({
     developerInfo: 'Codex host plugin',
     clientType: 'codex',
     baseUrl: values['base-url'],
+    requestedAgentId: existingAgentId,
 }, {
     onSubmitted: (requestId) => {
         console.log(`Registration submitted (request ID: ${requestId}).`);

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.2.0",
+  "version": "0.4.0",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/host.js",
@@ -22,7 +22,7 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@canonmsg/core": "^0.3.0"
+    "@canonmsg/core": "^0.5.0"
   },
   "engines": {
     "node": ">=18.0.0"