@canonmsg/codex-plugin 0.20.0 → 0.21.0

package/dist/inbound-policy.d.ts

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

package/dist/inbound-policy.js

@@ -0,0 +1,46 @@
+import { buildCompactGroupContextLines, evaluateParticipationPolicy, resolveAgentBehaviorPolicy, } from '@canonmsg/core';
+function formatRecentSenders(senderTypes) {
+    if (senderTypes.length === 0)
+        return 'none';
+    return senderTypes.map((senderType) => (senderType === 'ai_agent' ? 'agent' : 'human')).join(' -> ');
+}
+export function buildInboundContextLines(context) {
+    const conversationTypeLabel = context.conversationType === 'unknown'
+        ? 'unknown'
+        : `${context.conversationType}${context.memberCount ? ` (${context.memberCount} members)` : ''}`;
+    const senderRole = context.isOwner
+        ? 'The latest sender is the verified human owner of this Canon agent.'
+        : context.senderType === 'ai_agent'
+            ? 'The latest sender is another AI agent in Canon.'
+            : 'The latest sender is a human Canon participant.';
+    return [
+        senderRole,
+        `Latest sender name: ${context.senderName}`,
+        `Latest sender type: ${context.senderType}`,
+        `Conversation type: ${conversationTypeLabel}`,
+        ...(context.groupContext && context.groupContextMode
+            ? buildCompactGroupContextLines(context.groupContext, context.groupContextMode)
+            : []),
+        `Directly addressed to this agent: ${context.mentionedAgent ? 'yes' : 'no'}`,
+        `Recent sender pattern: ${formatRecentSenders(context.recentSenderTypes)}`,
+        `Recent human messages: ${context.recentHumanCount}`,
+        `Recent agent messages: ${context.recentAgentCount}`,
+        `Consecutive recent agent turns: ${context.consecutiveAgentTurns}`,
+        `Current agent streak started after a human message: ${context.currentAgentStreakStartedByHuman ? 'yes' : 'no'}`,
+    ];
+}
+export function decideAutoReply(context, behavior) {
+    const decision = evaluateParticipationPolicy(behavior ?? resolveAgentBehaviorPolicy(), {
+        conversationType: context.conversationType,
+        senderType: context.senderType,
+        isOwner: context.isOwner,
+        mentionedAgent: context.mentionedAgent,
+        recentHumanCount: context.recentHumanCount,
+        consecutiveAgentTurns: context.consecutiveAgentTurns,
+        currentAgentStreakStartedByHuman: context.currentAgentStreakStartedByHuman,
+    });
+    return {
+        allow: decision.allow,
+        reason: decision.reason,
+    };
+}

package/dist/permission-mode.d.ts

@@ -1,4 +1,4 @@
-import type { CodexSandboxMode } from './app-server-adapter.js';
+import type { CodexSandboxMode } from './adapter.js';
 export declare const CODEX_PERMISSION_OPTIONS: readonly [{
     readonly value: "readonly";
     readonly label: "Read-only";

package/dist/register.js

@@ -2,45 +2,8 @@
 import { setDefaultResultOrder } from 'node:dns';
 import { readFileSync } from 'node:fs';
 import { parseArgs } from 'node:util';
-import { ackRegistrationApprovalWith, resolveCanonBaseUrl, runRegistrationFlow, } from '@canonmsg/core/contract';
-import { clearPendingRegistration, getOrCreatePendingRegistration, updatePendingRegistration, upsertAgentProfile, AGENTS_PATH, } from '@canonmsg/core/local';
-import { resolvePackagedBridgeBin } from './bridge-bin.js';
-import { connectBridge } from '@canonmsg/framework';
+import { ackRegistrationApproval, clearPendingRegistration, getOrCreatePendingRegistration, registerAndWaitForApproval, updatePendingRegistration, upsertAgentProfile, AGENTS_PATH, } from '@canonmsg/core';
 import { runCli } from './cli-entry.js';
-/**
- * Registration rides the bridge (Phase 6, same shape as the Hermes port): a
- * short-lived PRE-IDENTITY registration daemon (offline stub +
- * CANON_BRIDGE_REGISTRATION_BASE_URL, managed-child so it dies with this
- * process) serves the three unauthenticated §B10 routes over JSON-RPC.
- */
-async function openRegistrationBridge(baseUrl) {
-    return connectBridge({
-        profile: 'registration',
-        mode: 'managed-child',
-        ...(resolvePackagedBridgeBin() ? { binPath: resolvePackagedBridgeBin() } : {}),
-        env: {
-            ...process.env,
-            CANON_BRIDGE_AGENT_ID: 'canon-registration',
-            CANON_BRIDGE_REGISTRATION_BASE_URL: baseUrl,
-        },
-        hello: { clientType: 'codex', wantFamilies: [] },
-    });
-}
-function bridgeRegistrationTransport(bridge) {
-    return {
-        register: (_baseUrl, body) => bridge.client.call('register', body),
-        checkStatus: (_baseUrl, requestId, pollToken) => bridge.client.call('getRegistrationStatus', {
-            requestId,
-            ...(pollToken ? { pollToken } : {}),
-        }),
-        ackRegistrationStatus: async (_baseUrl, requestId, pollToken) => {
-            await bridge.client.call('ackRegistrationStatus', {
-                requestId,
-                ...(pollToken ? { pollToken } : {}),
-            });
-        },
-    };
-}
 const HELP = `canon-codex-register — register or reconnect a Codex agent in Canon
 
 USAGE
@@ -89,39 +52,29 @@ export async function main() {
     }
     console.log(`Registering Codex agent "${values.name}" (profile: ${profileName})...`);
     const pending = getOrCreatePendingRegistration(profileName, 'codex');
-    const baseUrl = resolveCanonBaseUrl(values['base-url']);
-    const bridge = await openRegistrationBridge(baseUrl);
-    const transport = bridgeRegistrationTransport(bridge);
-    let result;
-    try {
-        result = await runRegistrationFlow({
-            name: values.name,
-            description: values.description,
-            ownerPhone: values.phone,
-            developerInfo: 'Codex host plugin',
-            clientType: 'codex',
-            baseUrl: values['base-url'],
-            requestedAgentId: existingAgentId,
-            localRegistrationId: pending.localRegistrationId,
-        }, transport, {
-            onSubmitted: (requestId, pollToken) => {
-                updatePendingRegistration(profileName, {
-                    requestId,
-                    pollToken,
-                    clientType: 'codex',
-                });
-                console.log(`Registration submitted (request ID: ${requestId}).`);
-                console.log('Waiting for approval in Canon app...');
-            },
-            onPollUpdate: () => {
-                process.stdout.write('.');
-            },
-        });
-    }
-    catch (error) {
-        bridge.client.close();
-        throw error;
-    }
+    const result = await registerAndWaitForApproval({
+        name: values.name,
+        description: values.description,
+        ownerPhone: values.phone,
+        developerInfo: 'Codex host plugin',
+        clientType: 'codex',
+        baseUrl: values['base-url'],
+        requestedAgentId: existingAgentId,
+        localRegistrationId: pending.localRegistrationId,
+    }, {
+        onSubmitted: (requestId, pollToken) => {
+            updatePendingRegistration(profileName, {
+                requestId,
+                pollToken,
+                clientType: 'codex',
+            });
+            console.log(`Registration submitted (request ID: ${requestId}).`);
+            console.log('Waiting for approval in Canon app...');
+        },
+        onPollUpdate: () => {
+            process.stdout.write('.');
+        },
+    });
     console.log('');
     switch (result.status) {
         case 'approved': {
@@ -138,7 +91,7 @@ export async function main() {
                 ...(typeof values['base-url'] === 'string' ? { baseUrl: values['base-url'] } : {}),
             });
             if (result.requestId) {
-                await ackRegistrationApprovalWith(transport, values['base-url'], result.requestId, result.pollToken);
+                await ackRegistrationApproval(values['base-url'], result.requestId, result.pollToken);
             }
             clearPendingRegistration(profileName);
             console.log(`Approved! Agent: ${result.agentName} (${result.agentId})`);
@@ -158,7 +111,6 @@ export async function main() {
             process.exit(1);
             break;
     }
-    bridge.client.close();
 }
 runCli(import.meta.url, main, (error) => {
     console.error('[canon-codex-register] Fatal error:', error);

package/dist/session-store.d.ts

@@ -1,4 +1,4 @@
-import { type ExecutionEnvironmentMode } from '@canonmsg/core/local';
+import { type ExecutionEnvironmentMode } from '@canonmsg/core';
 export declare function buildCodexThreadPolicyFingerprint(input: {
     baseCwd: string;
     executionMode?: ExecutionEnvironmentMode;

package/dist/session-store.js

@@ -1,7 +1,7 @@
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { createHash } from 'node:crypto';
 import { join } from 'node:path';
-import { CANON_DIR, clearRuntimeSessionState, loadRuntimeSessionState, saveRuntimeSessionState, } from '@canonmsg/core/local';
+import { CANON_DIR, clearRuntimeSessionState, loadRuntimeSessionState, saveRuntimeSessionState, } from '@canonmsg/core';
 const STORE_PATH = join(CANON_DIR, 'codex-sessions.json');
 function loadStore() {
     try {

package/dist/startup-recovery.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Startup recovery for inbound messages missed while the host was offline.
+ *
+ * The host persists a `lastInboundMessageId` cursor per conversation. On
+ * startup we paginate `getMessagesPage` (newest-first pages, older pages via
+ * its `before` message-id parameter) until the cursor is found or a hard
+ * per-conversation bound is hit, then replay everything after the cursor.
+ *
+ * This module is intentionally identical in packages/claude-code-plugin and
+ * packages/codex-plugin — keep both copies in sync (future consolidation
+ * candidate).
+ */
+export declare const STARTUP_RECOVERY_PAGE_SIZE = 25;
+export declare const STARTUP_RECOVERY_MAX_MESSAGES = 500;
+export interface StartupRecoveryMessage {
+    id: string;
+    senderId: string;
+    createdAt?: string;
+}
+export interface StartupRecoveryPage {
+    messages: StartupRecoveryMessage[];
+}
+export type StartupRecoveryMode = 
+/** Cursor found — `messages` is everything strictly after it. */
+'after-cursor'
+/** Cursor present but not found within the bound — `messages` is the bounded recent window. */
+ | 'truncated-window'
+/**
+ * No usable cursor (fresh runtime file, or the cursor message no longer
+ * exists in history) — only the newest inbound message is recovered, since
+ * a full-history replay could fire mass duplicate turns.
+ */
+ | 'latest-only';
+export interface StartupRecoveryResult<TPage extends StartupRecoveryPage> {
+    mode: StartupRecoveryMode;
+    /** Missed inbound messages (own messages excluded), oldest first. */
+    messages: TPage['messages'];
+    /** First page fetched — reusable as hydration context for recovered turns. */
+    newestPage: TPage;
+}
+export declare function collectMissedInboundMessages<TPage extends StartupRecoveryPage>(input: {
+    fetchPage: (before?: string) => Promise<TPage>;
+    cursor: string | null | undefined;
+    agentId: string;
+    maxMessages?: number;
+}): Promise<StartupRecoveryResult<TPage>>;

package/dist/startup-recovery.js

@@ -0,0 +1,59 @@
+/**
+ * Startup recovery for inbound messages missed while the host was offline.
+ *
+ * The host persists a `lastInboundMessageId` cursor per conversation. On
+ * startup we paginate `getMessagesPage` (newest-first pages, older pages via
+ * its `before` message-id parameter) until the cursor is found or a hard
+ * per-conversation bound is hit, then replay everything after the cursor.
+ *
+ * This module is intentionally identical in packages/claude-code-plugin and
+ * packages/codex-plugin — keep both copies in sync (future consolidation
+ * candidate).
+ */
+export const STARTUP_RECOVERY_PAGE_SIZE = 25;
+export const STARTUP_RECOVERY_MAX_MESSAGES = 500;
+export async function collectMissedInboundMessages(input) {
+    const maxMessages = input.maxMessages ?? STARTUP_RECOVERY_MAX_MESSAGES;
+    const newestPage = await input.fetchPage();
+    const collected = [...newestPage.messages];
+    const seenIds = new Set(collected.map((message) => message.id));
+    const hasCursor = (messages) => input.cursor != null && messages.some((message) => message.id === input.cursor);
+    let cursorFound = hasCursor(collected);
+    if (input.cursor != null) {
+        while (!cursorFound && collected.length < maxMessages) {
+            // Pages are newest-first, so the last collected message is the oldest.
+            const before = collected[collected.length - 1]?.id;
+            if (!before)
+                break;
+            const page = await input.fetchPage(before);
+            const fresh = page.messages.filter((message) => !seenIds.has(message.id));
+            // No pagination progress (history exhausted, or the server ignored the
+            // `before` cursor because that message was hard-deleted) — stop here.
+            if (fresh.length === 0)
+                break;
+            for (const message of fresh)
+                seenIds.add(message.id);
+            collected.push(...fresh);
+            cursorFound = hasCursor(fresh);
+        }
+    }
+    const ascending = [...collected].sort((a, b) => String(a.createdAt ?? '').localeCompare(String(b.createdAt ?? '')));
+    const inboundOnly = (messages) => messages.filter((message) => message.senderId !== input.agentId);
+    let mode;
+    let missed;
+    if (cursorFound) {
+        const cursorIndex = ascending.findIndex((message) => message.id === input.cursor);
+        mode = 'after-cursor';
+        missed = inboundOnly(ascending.slice(cursorIndex + 1));
+    }
+    else if (input.cursor != null && collected.length >= maxMessages) {
+        mode = 'truncated-window';
+        missed = inboundOnly(ascending.slice(-maxMessages));
+    }
+    else {
+        mode = 'latest-only';
+        missed = inboundOnly(ascending).slice(-1);
+    }
+    // Safe: `missed` only holds elements of pages returned by `fetchPage`.
+    return { mode, messages: missed, newestPage };
+}

package/dist/turn-activity.d.ts

@@ -1,39 +1,24 @@
-import type { TurnOutputBlock } from '@canonmsg/core/contract';
+import type { TurnOutputBlock } from '@canonmsg/core';
 interface RunningCommandBlock {
     command: string;
     blockId: string;
     itemId?: string;
 }
-/**
- * True once the streaming output already carries assistant speech (folded
- * text segments). While speech is flowing the host must not flap the bubble
- * status to tool/thinking or clobber the live text with plan snapshots — the
- * staged margin blocks already narrate that activity, and every status/text
- * swap makes the smoothed bubble snap.
- */
-export declare function hasSpeechSegmentText(blocks: ReadonlyArray<Pick<TurnOutputBlock, 'kind' | 'text'>>): boolean;
 export interface CommandBlockTracker {
     sequence: number;
     running: RunningCommandBlock[];
 }
-export declare function createCommandBlockTracker(): CommandBlockTracker;
-/**
- * Stable block id for one assistant text segment. The segment state itself
- * (snapshot replacement + live-text rebuild around activity blocks) lives in
- * core's TurnOutputController (`replaceTextSegmentSnapshot`) — this module
- * only owns the codex id scheme.
- */
-export declare function textSegmentBlockId(turnId: string | null | undefined, itemId?: string): string;
-export interface CodexTextSegmentOutput {
-    appendTextSegmentDelta(id: string, delta: string): void;
-    replaceTextSegmentSnapshot(id: string, text: string): void;
+export interface TextSegmentBlockState {
+    turnLiveText: string;
+    turnBlocks: TurnOutputBlock[];
 }
-export declare function applyCodexMessageToStreamingOutput(output: CodexTextSegmentOutput, input: {
+export declare function createCommandBlockTracker(): CommandBlockTracker;
+export declare function applyTextSegmentBlock(state: TextSegmentBlockState, input: {
     turnId: string | null | undefined;
     itemId?: string;
     text: string;
-    delta?: string;
-}): void;
+    now?: number;
+}): TextSegmentBlockState;
 export declare function beginCommandBlock(tracker: CommandBlockTracker, input: {
     turnId: string | null | undefined;
     command: string;

package/dist/turn-activity.js

@@ -1,13 +1,3 @@
-/**
- * True once the streaming output already carries assistant speech (folded
- * text segments). While speech is flowing the host must not flap the bubble
- * status to tool/thinking or clobber the live text with plan snapshots — the
- * staged margin blocks already narrate that activity, and every status/text
- * swap makes the smoothed bubble snap.
- */
-export function hasSpeechSegmentText(blocks) {
-    return blocks.some((block) => block.kind === 'text' && Boolean(block.text?.trim()));
-}
 export function createCommandBlockTracker() {
     return {
         sequence: 0,
@@ -18,22 +8,48 @@ function normalizeOptionalString(value) {
     const normalized = value?.trim();
     return normalized ? normalized : undefined;
 }
-/**
- * Stable block id for one assistant text segment. The segment state itself
- * (snapshot replacement + live-text rebuild around activity blocks) lives in
- * core's TurnOutputController (`replaceTextSegmentSnapshot`) — this module
- * only owns the codex id scheme.
- */
-export function textSegmentBlockId(turnId, itemId) {
+function textBlockId(turnId, itemId) {
     return `message:${turnId ?? 'turn'}:${normalizeOptionalString(itemId) ?? 'latest'}`;
 }
-export function applyCodexMessageToStreamingOutput(output, input) {
-    const segmentId = textSegmentBlockId(input.turnId, input.itemId);
-    if (input.delta !== undefined) {
-        output.appendTextSegmentDelta(segmentId, input.delta);
-        return;
-    }
-    output.replaceTextSegmentSnapshot(segmentId, input.text);
+function buildLiveText(blocks) {
+    return blocks
+        .filter((block) => block.kind === 'text' && block.text?.trim())
+        .sort((left, right) => {
+        if (left.sequence !== right.sequence)
+            return left.sequence - right.sequence;
+        return left.id.localeCompare(right.id);
+    })
+        .map((block) => block.text)
+        .join('\n\n');
+}
+export function applyTextSegmentBlock(state, input) {
+    const id = textBlockId(input.turnId, input.itemId);
+    const now = input.now ?? Date.now();
+    const index = state.turnBlocks.findIndex((block) => block.id === id);
+    const existing = index >= 0 ? state.turnBlocks[index] : null;
+    const next = {
+        ...(existing ?? {
+            sequence: state.turnBlocks.length + 1,
+            createdAt: now,
+        }),
+        id,
+        turnId: input.turnId ?? id,
+        kind: 'text',
+        status: existing?.status ?? 'running',
+        text: input.text,
+        updatedAt: now,
+    };
+    const turnBlocks = index >= 0
+        ? [
+            ...state.turnBlocks.slice(0, index),
+            next,
+            ...state.turnBlocks.slice(index + 1),
+        ]
+        : [...state.turnBlocks, next];
+    return {
+        turnBlocks,
+        turnLiveText: buildLiveText(turnBlocks) || state.turnLiveText,
+    };
 }
 function nextCommandBlockId(tracker, turnId, itemId) {
     const stableTurnId = turnId ?? 'turn';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/index.js",
@@ -21,7 +21,7 @@
     "scripts"
   ],
   "scripts": {
-    "prepare:workspace-deps": "node ../../scripts/run-workspace-prep.mjs ../../packages/core ../../packages/agent-sdk ../../packages/framework ../../packages/bridge ../../packages/agent-host",
+    "prepare:workspace-deps": "node ../../scripts/run-workspace-prep.mjs ../core ../agent-sdk ../coding-agent-host",
     "build": "npm run prepare:workspace-deps && node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
     "dev": "npm run prepare:workspace-deps && tsc --watch",
     "smoke": "node scripts/smoke-test.mjs",
@@ -29,12 +29,9 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@canonmsg/agent-host": "^0.5.0",
-    "@canonmsg/agent-sdk": "^4.0.0",
-    "@canonmsg/backend-contracts": "^1.9.0",
-    "@canonmsg/bridge": "^0.3.0",
-    "@canonmsg/core": "^3.3.0",
-    "@canonmsg/framework": "^0.3.0"
+    "@canonmsg/agent-sdk": "^5.0.0",
+    "@canonmsg/coding-agent-host": "^0.2.2",
+    "@canonmsg/core": "^4.0.0"
   },
   "engines": {
     "node": ">=18.0.0"
@@ -49,9 +46,9 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/HeyBobChan/canon",
-    "directory": "adapters/codex-plugin"
+    "directory": "packages/codex-plugin"
   },
-  "homepage": "https://github.com/HeyBobChan/canon/tree/main/adapters/codex-plugin",
+  "homepage": "https://github.com/HeyBobChan/canon/tree/main/packages/codex-plugin",
   "publishConfig": {
     "access": "public"
   },

package/dist/bridge-bin.d.ts

@@ -1,14 +0,0 @@
-/**
- * Packaged canon-bridge daemon resolution (bridge plan Phase 6, §F3).
- *
- * On a fresh npm install nothing has populated ~/.canon/bin yet, so
- * connectBridge()'s fallback chain (explicit binPath → $CANON_BRIDGE_BIN →
- * the shared install) has nothing to spawn. The plugin therefore ships the
- * daemon as its own @canonmsg/bridge dependency and passes the packaged
- * dist entry as binPath.
- *
- * $CANON_BRIDGE_BIN still wins: when the env override is set we return
- * undefined and let connectBridge()'s own env resolution take it (an
- * options.binPath would out-rank the env var otherwise).
- */
-export declare function resolvePackagedBridgeBin(env?: NodeJS.ProcessEnv): string | undefined;

package/dist/bridge-bin.js

@@ -1,27 +0,0 @@
-/**
- * Packaged canon-bridge daemon resolution (bridge plan Phase 6, §F3).
- *
- * On a fresh npm install nothing has populated ~/.canon/bin yet, so
- * connectBridge()'s fallback chain (explicit binPath → $CANON_BRIDGE_BIN →
- * the shared install) has nothing to spawn. The plugin therefore ships the
- * daemon as its own @canonmsg/bridge dependency and passes the packaged
- * dist entry as binPath.
- *
- * $CANON_BRIDGE_BIN still wins: when the env override is set we return
- * undefined and let connectBridge()'s own env resolution take it (an
- * options.binPath would out-rank the env var otherwise).
- */
-import { createRequire } from 'node:module';
-import { dirname, join as joinPath } from 'node:path';
-export function resolvePackagedBridgeBin(env = process.env) {
-    if (env.CANON_BRIDGE_BIN)
-        return undefined;
-    try {
-        const require = createRequire(import.meta.url);
-        const manifestPath = require.resolve('@canonmsg/bridge/package.json');
-        return joinPath(dirname(manifestPath), 'dist', 'main.js');
-    }
-    catch {
-        return undefined;
-    }
-}