@canonmsg/codex-plugin 0.20.0 → 0.22.0

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;