@canonmsg/codex-plugin 0.19.2 → 0.21.0

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 adapters/codex-plugin/dist/host.js --cwd /path/to/project --full-auto
+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:
@@ -149,7 +149,7 @@ CANON_AGENT=frontend canon-codex --cwd ~/projects/frontend
 ## Development
 
 ```bash
-cd adapters/codex-plugin
+cd packages/codex-plugin
 npm install
 npm run build
 ```

package/dist/adapter.d.ts

@@ -8,7 +8,6 @@ export type CodexEvent = {
 } | {
     type: 'message';
     text: string;
-    delta?: string;
     itemId?: string;
 } | {
     type: 'plan.updated';

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

@@ -39,7 +39,6 @@ export declare class CodexAppServerAdapter {
     private skillsCache;
     private messageTextByItem;
     private planText;
-    private traceTurnEpochMs;
     constructor(opts: {
         cwd: string;
         threadId?: string | null;
@@ -85,18 +84,9 @@ 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;
     private sendRequest;
     private write;
-    private trace;
-    private traceLine;
 }

package/dist/app-server-adapter.js

@@ -31,7 +31,6 @@ export class CodexAppServerAdapter {
     skillsCache = null;
     messageTextByItem = new Map();
     planText = '';
-    traceTurnEpochMs = null;
     constructor(opts) {
         this.cwd = opts.cwd;
         this.threadId = opts.threadId ?? null;
@@ -118,8 +117,6 @@ export class CodexAppServerAdapter {
         this.interrupted = false;
         this.messageTextByItem.clear();
         this.planText = '';
-        this.traceTurnEpochMs = Date.now();
-        this.trace('turn/run begin');
         try {
             if (this.threadId && this.loadedThreadId !== this.threadId) {
                 const resumed = await this.sendRequest('thread/resume', {
@@ -161,11 +158,9 @@ export class CodexAppServerAdapter {
                 this.currentTurnReject = reject;
             });
             turnPromise.catch(() => { });
-            const turnInput = await this.buildTurnInput(prompt, imagePaths);
-            this.trace('turn/start sent');
             const turnStarted = await this.sendRequest('turn/start', {
                 threadId: this.threadId,
-                input: turnInput,
+                input: await this.buildTurnInput(prompt, imagePaths),
                 ...(this.model ? { model: this.model } : {}),
                 ...this.sandboxPolicyPayload(_extraAddDirs),
                 collaborationMode: {
@@ -177,7 +172,6 @@ export class CodexAppServerAdapter {
                     },
                 },
             });
-            this.trace('turn/start ack');
             const turn = turnStarted.turn;
             if (this.currentTurnResolve) {
                 this.currentTurnId = readString(turn, 'id') ?? null;
@@ -328,7 +322,6 @@ export class CodexAppServerAdapter {
         const message = parseJson(line);
         if (!message)
             return;
-        this.traceLine(line, message);
         if ('id' in message && ('result' in message || 'error' in message) && !('method' in message)) {
             const id = Number(message.id);
             const pending = this.pending.get(id);
@@ -400,9 +393,9 @@ export class CodexAppServerAdapter {
             const delta = readRawString(params, 'delta') ?? '';
             const next = `${this.messageTextByItem.get(itemId) ?? ''}${delta}`;
             this.messageTextByItem.set(itemId, next);
-            this.currentFinalMessage = this.joinedAgentMessageText() ?? this.currentFinalMessage;
+            this.currentFinalMessage = next.trim() ? next : this.currentFinalMessage;
             if (next.trim())
-                this.currentOnEvent?.({ type: 'message', text: next, delta, itemId });
+                this.currentOnEvent?.({ type: 'message', text: next, itemId });
             return;
         }
         if (method === 'turn/plan/updated') {
@@ -439,8 +432,7 @@ export class CodexAppServerAdapter {
                 const itemId = readString(item, 'id');
                 const text = readString(item, 'text');
                 if (text) {
-                    this.messageTextByItem.set(itemId ?? 'agent-message', text);
-                    this.currentFinalMessage = this.joinedAgentMessageText() ?? text;
+                    this.currentFinalMessage = text;
                     this.currentOnEvent?.({
                         type: 'message',
                         text,
@@ -474,7 +466,6 @@ export class CodexAppServerAdapter {
             return;
         }
         if (method === 'turn/completed') {
-            this.trace('turn/completed notification');
             const turn = params.turn;
             const status = turn?.status;
             if (isRecord(status) && status.type === 'failed') {
@@ -495,18 +486,6 @@ 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)
@@ -538,7 +517,6 @@ export class CodexAppServerAdapter {
         this.currentErrorText = null;
         this.messageTextByItem.clear();
         this.planText = '';
-        this.traceTurnEpochMs = null;
     }
     sendRequest(method, params) {
         const id = this.requestSeq++;
@@ -558,33 +536,6 @@ export class CodexAppServerAdapter {
             throw new Error('Codex app-server is not running');
         this.child.stdin.write(`${JSON.stringify(message)}\n`);
     }
-    trace(message) {
-        if (!isCodexTraceEnabled())
-            return;
-        const elapsedMs = this.traceTurnEpochMs === null ? 0 : Date.now() - this.traceTurnEpochMs;
-        console.error(`[canon-codex-trace] +${elapsedMs}ms ${message}`);
-    }
-    traceLine(line, message) {
-        if (!isCodexTraceEnabled())
-            return;
-        const method = typeof message.method === 'string' ? message.method : null;
-        if (!method) {
-            const id = 'id' in message ? ` id=${String(message.id)}` : '';
-            this.trace(`line bytes=${line.length} response${id}`);
-            return;
-        }
-        if (method === 'item/agentMessage/delta') {
-            const params = isRecord(message.params) ? message.params : {};
-            const itemId = readString(params, 'itemId') ?? 'agent-message';
-            const delta = readRawString(params, 'delta') ?? '';
-            this.trace(`line bytes=${line.length} method=${method} itemId=${itemId} deltaLen=${delta.length}`);
-            return;
-        }
-        this.trace(`line bytes=${line.length} method=${method}`);
-    }
-}
-function isCodexTraceEnabled() {
-    return process.env.CANON_CODEX_TRACE_EVENTS === '1';
 }
 function parseJson(line) {
     try {

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

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

package/dist/app-server-approval.js

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

package/dist/cli-entry.d.ts

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

package/dist/cli-entry.js

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

package/dist/control-channel.d.ts

@@ -1,32 +1,52 @@
 /**
- * Codex host control-channel wiring (bridge notifications).
+ * Codex host RTDB `/control/{conversationId}/{agentId}` channel wiring.
  *
- * 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.
+ * 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):
  *
- * 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.
+ * - 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.
  */
-import type { ControlPrimitiveEventRecord, ControlSessionEventRecord, ControlSignalEventRecord } from '@canonmsg/backend-contracts';
-import { type ControlNotificationSource, type HostControlHandlerResult } from '@canonmsg/agent-host';
+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;
 export interface CodexControlChannelInput {
-    /** 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;
+    /** 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;
 }
-/** Wire the codex control handlers to the bridge notifications; returns detach. */
-export declare function attachCodexControlNotifications(input: CodexControlChannelInput): () => void;
+export declare function createCodexControlPoller(input: CodexControlChannelInput): ControlChannelPoller;

package/dist/control-channel.js

@@ -1,43 +1,56 @@
 /**
- * Codex host control-channel wiring (bridge notifications).
+ * Codex host RTDB `/control/{conversationId}/{agentId}` channel wiring.
  *
- * 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.
+ * 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):
  *
- * 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.
+ * - 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.
  */
-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);
+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 } : {}),
     });
-    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-lifecycle.d.ts

@@ -0,0 +1,4 @@
+export interface LongLivedStream {
+    start(): Promise<void>;
+}
+export declare function startCodexStreamInBackground(stream: LongLivedStream, onError: (error: unknown) => void): void;

package/dist/host-lifecycle.js

@@ -0,0 +1,3 @@
+export function startCodexStreamInBackground(stream, onError) {
+    stream.start().catch(onError);
+}

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/contract';
+import { type CanonRuntimeCommandDescriptor, type CanonRuntimeDescriptor, type CanonRuntimePresentationPolicy, type ExecutionEnvironmentMode, type WorkspaceOption, type CanonWorkspaceRootMetadata } from '@canonmsg/core';
 import { type CodexSkillMetadata } from './app-server-adapter.js';
 interface HostSessionState {
     lastError?: string;