@canonmsg/codex-plugin 0.18.10 → 0.18.11

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

@@ -64,6 +64,7 @@ export declare class CodexAppServerAdapter {
     setReasoningEffort(effort: string | null): void;
     isRunning(): boolean;
     interrupt(): Promise<void>;
+    compactThread(): Promise<void>;
     close(): void;
     runTurn(prompt: string, onEvent: (event: CodexEvent) => void, onLog?: (line: string) => void, imagePaths?: readonly string[], _extraAddDirs?: readonly string[], options?: CodexRunTurnOptions): Promise<CodexTurnResult>;
     private resolveApprovalPolicy;

package/dist/app-server-adapter.js

@@ -83,6 +83,15 @@ export class CodexAppServerAdapter {
             turnId: this.currentTurnId,
         }).catch(() => { });
     }
+    async compactThread() {
+        if (!this.threadId) {
+            throw new Error('No Codex thread to compact');
+        }
+        await this.ensureStarted();
+        await this.sendRequest('thread/compact/start', {
+            threadId: this.threadId,
+        });
+    }
     close() {
         this.child?.kill('SIGTERM');
         this.child = null;

package/dist/control-channel.d.ts

@@ -5,8 +5,9 @@
  * codex host characterization profile (the "codex host profile" describe
  * block in core's control-poller.test.ts is the contract):
  *
- * - Keys: `session` + `signal` (never `primitive`), read sequentially per
- *   conversation, conversations polled one at a time.
+ * - 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
@@ -15,7 +16,7 @@
  * - Dedupe is primed eagerly via `poller.baseline([conversationId])` at
  *   session creation — the second legacy poll site.
  */
-import { ControlChannelPoller, type ControlChannelRTDB, type ControlHandlerResult, type ControlPollerError, type ControlSessionEvent, type ControlSignalEvent } from '@canonmsg/core';
+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;
@@ -38,6 +39,12 @@ export interface CodexControlChannelInput {
      * 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;

package/dist/control-channel.js

@@ -5,8 +5,9 @@
  * codex host characterization profile (the "codex host profile" describe
  * block in core's control-poller.test.ts is the contract):
  *
- * - Keys: `session` + `signal` (never `primitive`), read sequentially per
- *   conversation, conversations polled one at a time.
+ * - 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
@@ -41,6 +42,13 @@ export function createCodexControlPoller(input) {
             signal: {
                 handle: input.onSignal,
             },
+            ...(input.onPrimitive
+                ? {
+                    primitive: {
+                        handle: input.onPrimitive,
+                    },
+                }
+                : {}),
         },
         ...(input.onError ? { onError: input.onError } : {}),
         ...(input.random ? { random: input.random } : {}),

package/dist/host.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { type CanonRuntimeCommandDescriptor, type ExecutionEnvironmentMode } from '@canonmsg/core';
+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;
@@ -51,5 +51,24 @@ export declare const CODEX_EFFORT_OPTIONS: readonly [{
 }];
 export declare const CODEX_SESSION_CONFIG_FIELDS: readonly ["permissionMode", "effort"];
 export declare function buildCodexSkillCommands(skills: ReadonlyArray<CodexSkillMetadata>): CanonRuntimeCommandDescriptor[];
+export declare function buildCodexRuntimeDescriptor(input: {
+    models: Array<{
+        value: string;
+        label: string;
+    }>;
+    workspaces: WorkspaceOption[];
+    workspaceRoots?: CanonWorkspaceRootMetadata[];
+    executionModes: ExecutionEnvironmentMode[];
+    permissionModes: Array<{
+        value: string;
+        label: string;
+    }>;
+    defaultPermissionMode?: string;
+    presentation?: CanonRuntimePresentationPolicy;
+    supportsPlanMode: boolean;
+    supportsCompact?: boolean;
+    supportsRichCards?: boolean;
+    skills?: ReadonlyArray<CodexSkillMetadata>;
+}): CanonRuntimeDescriptor;
 export declare function main(): Promise<void>;
 export {};

package/dist/host.js

@@ -126,7 +126,7 @@ export function buildCodexSkillCommands(skills) {
         };
     });
 }
-function buildCodexRuntimeDescriptor(input) {
+export function buildCodexRuntimeDescriptor(input) {
     const commands = [
         {
             id: 'runtime-status',
@@ -146,6 +146,20 @@ function buildCodexRuntimeDescriptor(input) {
         RUNTIME_STOP_ACTION,
         RUNTIME_STOP_AND_DROP_ACTION,
     ];
+    if (input.supportsCompact) {
+        commands.push({
+            id: 'codex-compact-context',
+            label: 'Compact',
+            description: 'Ask Codex to compact the current thread context.',
+            primitive: 'context.compact',
+            aliases: ['compact'],
+            category: 'session',
+            placements: ['composer_slash', 'command_palette'],
+            availability: ['idle'],
+            ownerOnly: true,
+            dispatch: { kind: 'primitive', primitive: 'context.compact' },
+        });
+    }
     const skillCommands = input.skills?.length ? buildCodexSkillCommands(input.skills) : [];
     if (skillCommands.length) {
         commands.push(...skillCommands);
@@ -1742,6 +1756,7 @@ export async function main() {
             defaultPermissionMode: codexPermissionEnvelope.defaultPermissionMode,
             presentation: runtimePresentation,
             supportsPlanMode: useAppServer,
+            supportsCompact: useAppServer,
             supportsRichCards: useAppServer,
             skills: codexSkills,
         }),
@@ -1838,6 +1853,34 @@ export async function main() {
         clearStreaming(conversationId);
         typingSignals.clear(conversationId).catch(() => { });
     }
+    async function handleControlPrimitive(event) {
+        const { conversationId, value } = event;
+        const primitiveId = typeof value.id === 'string' ? value.id : '';
+        if (primitiveId !== 'context.compact') {
+            console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Ignoring unsupported primitive (${primitiveId || 'unknown'})`);
+            return;
+        }
+        const session = sessions.get(conversationId);
+        if (!session || session.closed) {
+            console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Cannot compact context: no live Codex session`);
+            return;
+        }
+        if (!(session.adapter instanceof CodexAppServerAdapter)) {
+            console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Cannot compact context: compact is only available for Codex app-server sessions`);
+            return;
+        }
+        try {
+            await session.adapter.compactThread();
+            console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Compact requested`);
+            writeState(session);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            session.state.lastError = `Could not compact Codex context: ${message}`;
+            console.error(`[canon-codex] [${conversationId.slice(0, 8)}] ${session.state.lastError}`);
+            writeState(session);
+        }
+    }
     const controlPoller = createCodexControlPoller({
         rtdb,
         agentId,
@@ -1848,6 +1891,7 @@ export async function main() {
             applySessionControl(conversationId, control);
         },
         onSignal: handleControlSignal,
+        onPrimitive: handleControlPrimitive,
         onError: (error) => {
             // The legacy loop ignored transient RTDB failures; keep read/consume
             // errors quiet but surface handler failures.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.18.10",
+  "version": "0.18.11",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/index.js",