@canonmsg/codex-plugin 0.18.12 → 0.19.1

package/README.md

@@ -108,7 +108,7 @@ 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
+node adapters/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:
@@ -149,7 +149,7 @@ CANON_AGENT=frontend canon-codex --cwd ~/projects/frontend
 ## Development
 
 ```bash
-cd packages/codex-plugin
+cd adapters/codex-plugin
 npm install
 npm run build
 ```

package/dist/app-server-adapter.d.ts

@@ -84,6 +84,13 @@ export declare class CodexAppServerAdapter {
     private handleLine;
     private handleServerRequest;
     private handleNotification;
+    /**
+     * The turn's final message is the JOIN of every agentMessage item, in
+     * insertion order — not just the last item. The streamed turn trail folds
+     * all items (one text segment per item), so the final text must match the
+     * streamed/folded text or the app renders the turn twice.
+     */
+    private joinedAgentMessageText;
     private isCurrentThreadNotification;
     private resolveCurrentTurn;
     private clearActiveTurn;

package/dist/app-server-adapter.js

@@ -393,7 +393,7 @@ export class CodexAppServerAdapter {
             const delta = readRawString(params, 'delta') ?? '';
             const next = `${this.messageTextByItem.get(itemId) ?? ''}${delta}`;
             this.messageTextByItem.set(itemId, next);
-            this.currentFinalMessage = next.trim() ? next : this.currentFinalMessage;
+            this.currentFinalMessage = this.joinedAgentMessageText() ?? this.currentFinalMessage;
             if (next.trim())
                 this.currentOnEvent?.({ type: 'message', text: next, itemId });
             return;
@@ -432,7 +432,8 @@ export class CodexAppServerAdapter {
                 const itemId = readString(item, 'id');
                 const text = readString(item, 'text');
                 if (text) {
-                    this.currentFinalMessage = text;
+                    this.messageTextByItem.set(itemId ?? 'agent-message', text);
+                    this.currentFinalMessage = this.joinedAgentMessageText() ?? text;
                     this.currentOnEvent?.({
                         type: 'message',
                         text,
@@ -486,6 +487,18 @@ export class CodexAppServerAdapter {
             this.currentErrorText = stringifyPreview(params);
         }
     }
+    /**
+     * The turn's final message is the JOIN of every agentMessage item, in
+     * insertion order — not just the last item. The streamed turn trail folds
+     * all items (one text segment per item), so the final text must match the
+     * streamed/folded text or the app renders the turn twice.
+     */
+    joinedAgentMessageText() {
+        const joined = [...this.messageTextByItem.values()]
+            .filter((text) => text.trim())
+            .join('\n\n');
+        return joined.trim() ? joined : null;
+    }
     isCurrentThreadNotification(params) {
         const threadId = readNotificationThreadId(params);
         if (threadId && this.threadId && threadId !== this.threadId)

package/dist/app-server-approval.d.ts

@@ -1,4 +1,4 @@
-import type { ApprovalNativeRequestMetadata, ApprovalRequestCategory, ApprovalRequestDetail, ApprovalResult, ApprovalRisk, CanonUnifiedDiff } from '@canonmsg/core';
+import type { ApprovalNativeRequestMetadata, ApprovalRequestCategory, ApprovalRequestDetail, ApprovalResult, ApprovalRisk, CanonUnifiedDiff } from '@canonmsg/core/contract';
 /**
  * Mapping for Codex app-server native approval requests.
  *

package/dist/app-server-approval.js

@@ -1,4 +1,4 @@
-import { sanitizeUnifiedDiffForSharing, truncateUnifiedDiff } from '@canonmsg/core';
+import { sanitizeUnifiedDiffForSharing, truncateUnifiedDiff } from '@canonmsg/core/contract';
 function isRecord(value) {
     return Boolean(value && typeof value === 'object' && !Array.isArray(value));
 }

package/dist/bridge-bin.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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

@@ -0,0 +1,27 @@
+/**
+ * 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;
+    }
+}

package/dist/cli-entry.d.ts

@@ -1,2 +1,2 @@
-export { handleCliMetadataRequest, isDirectExecution, readCliPackageVersion, runCli, } from '@canonmsg/core';
-export type { CliMetadata, RunCliMetadataOptions, } from '@canonmsg/core';
+export { handleCliMetadataRequest, isDirectExecution, readCliPackageVersion, runCli, } from '@canonmsg/core/local';
+export type { CliMetadata, RunCliMetadataOptions, } from '@canonmsg/core/local';

package/dist/cli-entry.js

@@ -1 +1 @@
-export { handleCliMetadataRequest, isDirectExecution, readCliPackageVersion, runCli, } from '@canonmsg/core';
+export { handleCliMetadataRequest, isDirectExecution, readCliPackageVersion, runCli, } from '@canonmsg/core/local';

package/dist/control-channel.d.ts

@@ -1,52 +1,32 @@
 /**
- * Codex host RTDB `/control/{conversationId}/{agentId}` channel wiring.
+ * Codex host control-channel wiring (bridge notifications).
  *
- * Configures the shared `ControlChannelPoller` from `@canonmsg/core` to the
- * codex host characterization profile (the "codex host profile" describe
- * block in core's control-poller.test.ts is the contract):
+ * Phase 6: the host-side RTDB `/control` poller is DELETED — the Bridge is
+ * the single authoritative consumer for this identity (one adaptive poller
+ * per daemon; cadence, jitter, baselines and consume semantics live there)
+ * and pushes `onSessionControl` / `onControlSignal` / `onControlPrimitive`
+ * notifications instead. This module keeps the codex-shaped handler wiring:
+ * session + signal ride the shared agent-host router; the primitive channel
+ * (context.compact) subscribes alongside them.
  *
- * - Keys: `session` + `signal`, plus `primitive` when a primitive handler is
- *   configured; read sequentially per conversation, conversations polled one
- *   at a time.
- * - Cadence: immediate first cycle, then active/idle delays + jitter with
- *   the activity probe sampled BEFORE the cycle runs.
- * - Session controls are always consumed once newer (default consume), even
- *   when no live session applied them; signals are NOT consumed when the
- *   handler throws (consumeOnError stays false).
- * - Dedupe is primed eagerly via `poller.baseline([conversationId])` at
- *   session creation — the second legacy poll site.
+ * Consume semantics note (deliberate Phase-6 change, plan §2): the node is
+ * consumed bridge-side BEFORE dispatch, so handler return values are
+ * advisory-only and a throwing handler is logged, never retried — the legacy
+ * leave-in-place-on-error behavior is gone with the host poller.
  */
-import { ControlChannelPoller, type ControlChannelRTDB, type ControlHandlerResult, type ControlPollerError, type ControlPrimitiveEvent, type ControlSessionEvent, type ControlSignalEvent } from '@canonmsg/core';
-export declare const CONTROL_POLL_MS = 2000;
-export declare const IDLE_CONTROL_POLL_MS = 10000;
-export declare const CONTROL_POLL_JITTER_MS = 1000;
+import type { ControlPrimitiveEventRecord, ControlSessionEventRecord, ControlSignalEventRecord } from '@canonmsg/backend-contracts';
+import { type ControlNotificationSource, type HostControlHandlerResult } from '@canonmsg/agent-host';
 export interface CodexControlChannelInput {
-    /** Scoped RTDB handle from `initRTDBAuth` — never the module-global default. */
-    rtdb: ControlChannelRTDB;
-    agentId: string;
-    /** Live session conversation ids, snapshotted at the start of every cycle. */
-    conversationIds: () => Iterable<string>;
-    /** Sampled before each cycle to choose the active vs idle delay. */
-    hasActiveWork: () => boolean;
-    /**
-     * Applies a newer `/session` control node. The node is always consumed
-     * after the handler resolves; a thrown error leaves it in place (with
-     * dedupe already advanced, so it is never retried).
-     */
-    onSessionControl: (event: ControlSessionEvent) => Promise<ControlHandlerResult> | ControlHandlerResult;
-    /**
-     * Handles a newer `/signal` node. Return `{ consume: false }` to leave the
-     * node in place; thrown errors also leave it (consumeOnError stays false).
-     */
-    onSignal: (event: ControlSignalEvent) => Promise<ControlHandlerResult> | ControlHandlerResult;
-    /**
-     * Handles a newer `/primitive` node. Primitive commands are consumed by
-     * default after the handler resolves or throws, matching core's command
-     * semantics so one failed command cannot replay forever.
-     */
-    onPrimitive?: (event: ControlPrimitiveEvent) => Promise<ControlHandlerResult> | ControlHandlerResult;
-    onError?: (error: ControlPollerError) => void;
-    /** Injectable jitter source (tests). */
-    random?: () => number;
+    /** Buffered notification source (registered before the hello completes). */
+    source: ControlNotificationSource;
+    /** Applies a `/session` control (model/effort; permission is start-only). */
+    onSessionControl: (event: ControlSessionEventRecord) => Promise<HostControlHandlerResult> | HostControlHandlerResult;
+    /** Handles a `/signal` node (interrupt / stop_and_drop / new_session). */
+    onSignal: (event: ControlSignalEventRecord) => Promise<HostControlHandlerResult> | HostControlHandlerResult;
+    /** Handles a `/primitive` command (context.compact). */
+    onPrimitive?: (event: ControlPrimitiveEventRecord) => Promise<HostControlHandlerResult> | HostControlHandlerResult;
+    /** Error sink for throwing handlers (default: console.error). */
+    onError?: (error: unknown, kind: 'session' | 'signal' | 'primitive', conversationId: string | null) => void;
 }
-export declare function createCodexControlPoller(input: CodexControlChannelInput): ControlChannelPoller;
+/** Wire the codex control handlers to the bridge notifications; returns detach. */
+export declare function attachCodexControlNotifications(input: CodexControlChannelInput): () => void;

package/dist/control-channel.js

@@ -1,56 +1,43 @@
 /**
- * Codex host RTDB `/control/{conversationId}/{agentId}` channel wiring.
+ * Codex host control-channel wiring (bridge notifications).
  *
- * Configures the shared `ControlChannelPoller` from `@canonmsg/core` to the
- * codex host characterization profile (the "codex host profile" describe
- * block in core's control-poller.test.ts is the contract):
+ * Phase 6: the host-side RTDB `/control` poller is DELETED — the Bridge is
+ * the single authoritative consumer for this identity (one adaptive poller
+ * per daemon; cadence, jitter, baselines and consume semantics live there)
+ * and pushes `onSessionControl` / `onControlSignal` / `onControlPrimitive`
+ * notifications instead. This module keeps the codex-shaped handler wiring:
+ * session + signal ride the shared agent-host router; the primitive channel
+ * (context.compact) subscribes alongside them.
  *
- * - Keys: `session` + `signal`, plus `primitive` when a primitive handler is
- *   configured; read sequentially per conversation, conversations polled one
- *   at a time.
- * - Cadence: immediate first cycle, then active/idle delays + jitter with
- *   the activity probe sampled BEFORE the cycle runs.
- * - Session controls are always consumed once newer (default consume), even
- *   when no live session applied them; signals are NOT consumed when the
- *   handler throws (consumeOnError stays false).
- * - Dedupe is primed eagerly via `poller.baseline([conversationId])` at
- *   session creation — the second legacy poll site.
+ * Consume semantics note (deliberate Phase-6 change, plan §2): the node is
+ * consumed bridge-side BEFORE dispatch, so handler return values are
+ * advisory-only and a throwing handler is logged, never retried — the legacy
+ * leave-in-place-on-error behavior is gone with the host poller.
  */
-import { ControlChannelPoller, } from '@canonmsg/core';
-export const CONTROL_POLL_MS = 2_000;
-export const IDLE_CONTROL_POLL_MS = 10_000;
-export const CONTROL_POLL_JITTER_MS = 1_000;
-export function createCodexControlPoller(input) {
-    return new ControlChannelPoller({
-        rtdb: input.rtdb,
-        agentId: input.agentId,
-        conversationIds: input.conversationIds,
-        cadence: {
-            kind: 'adaptive',
-            activeMs: CONTROL_POLL_MS,
-            idleMs: IDLE_CONTROL_POLL_MS,
-            jitterMs: CONTROL_POLL_JITTER_MS,
-            hasActiveWork: input.hasActiveWork,
-            activitySample: 'cycle-start',
-        },
-        pollOnStart: true,
-        conversationConcurrency: 'sequential',
-        handlers: {
-            session: {
-                handle: input.onSessionControl,
-            },
-            signal: {
-                handle: input.onSignal,
-            },
-            ...(input.onPrimitive
-                ? {
-                    primitive: {
-                        handle: input.onPrimitive,
-                    },
-                }
-                : {}),
-        },
-        ...(input.onError ? { onError: input.onError } : {}),
-        ...(input.random ? { random: input.random } : {}),
+import { attachHostControlNotifications, } from '@canonmsg/agent-host';
+/** Wire the codex control handlers to the bridge notifications; returns detach. */
+export function attachCodexControlNotifications(input) {
+    const report = input.onError ?? ((error, kind, conversationId) => {
+        const convo = conversationId ? ` [${conversationId.slice(0, 8)}]` : '';
+        console.error(`[canon-codex]${convo} Control ${kind} handler error:`, error);
     });
+    const detachShared = attachHostControlNotifications(input.source, { logPrefix: '[canon-codex]' }, {
+        onSessionControl: input.onSessionControl,
+        onControlSignal: input.onSignal,
+        onError: (error, kind, conversationId) => report(error, kind, conversationId),
+    });
+    let detachPrimitive = null;
+    if (input.onPrimitive) {
+        const onPrimitive = input.onPrimitive;
+        detachPrimitive = input.source.onNotification('onControlPrimitive', (params) => {
+            const event = params;
+            void Promise.resolve(onPrimitive(event)).catch((error) => {
+                report(error, 'primitive', event?.conversationId ?? null);
+            });
+        });
+    }
+    return () => {
+        detachShared();
+        detachPrimitive?.();
+    };
 }

package/dist/host.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { type CanonRuntimeCommandDescriptor, type CanonRuntimeDescriptor, type CanonRuntimePresentationPolicy, type ExecutionEnvironmentMode, type WorkspaceOption, type CanonWorkspaceRootMetadata } from '@canonmsg/core';
+import { type CanonRuntimeCommandDescriptor, type CanonRuntimeDescriptor, type CanonRuntimePresentationPolicy, type ExecutionEnvironmentMode, type WorkspaceOption, type CanonWorkspaceRootMetadata } from '@canonmsg/core/contract';
 import { type CodexSkillMetadata } from './app-server-adapter.js';
 interface HostSessionState {
     lastError?: string;