@canonmsg/codex-plugin 0.18.11 → 0.19.0

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;