@canonmsg/codex-plugin 0.18.9 → 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 } 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;
@@ -17,6 +17,21 @@ export declare function buildCodexInitialSessionState(input: {
     permissionMode?: string;
     effort?: string | null;
 }): HostSessionState;
+export declare function buildCodexLiveSessionConfig(input: {
+    model?: string;
+    permissionMode?: string;
+    effort?: string;
+    workspaceId?: string | null;
+    executionMode: ExecutionEnvironmentMode;
+    executionBranch?: string | null;
+}): {
+    executionMode: ExecutionEnvironmentMode;
+    executionBranch: string | null;
+    workspaceId?: string | undefined;
+    effort?: string | undefined;
+    permissionMode?: string | undefined;
+    model?: string | undefined;
+};
 /** GPT reasoning-effort levels, applied next turn via model_reasoning_effort. */
 export declare const CODEX_EFFORT_OPTIONS: readonly [{
     readonly value: "minimal";
@@ -34,6 +49,26 @@ export declare const CODEX_EFFORT_OPTIONS: readonly [{
     readonly value: "xhigh";
     readonly label: "Extra high";
 }];
+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

@@ -61,6 +61,16 @@ export function buildCodexInitialSessionState(input) {
         state: 'idle',
     };
 }
+export function buildCodexLiveSessionConfig(input) {
+    return {
+        ...(input.model ? { model: input.model } : {}),
+        ...(input.permissionMode ? { permissionMode: input.permissionMode } : {}),
+        ...(input.effort ? { effort: input.effort } : {}),
+        ...(input.workspaceId ? { workspaceId: input.workspaceId } : {}),
+        executionMode: input.executionMode,
+        executionBranch: input.executionBranch ?? null,
+    };
+}
 const MAX_SESSIONS = 12;
 const IDLE_TIMEOUT_MS = 30 * 60 * 1000;
 const HEARTBEAT_MS = 30_000;
@@ -85,6 +95,7 @@ export const CODEX_EFFORT_OPTIONS = [
     { value: 'xhigh', label: 'Extra high' },
 ];
 const CODEX_EFFORT_VALUES = new Set(CODEX_EFFORT_OPTIONS.map((option) => option.value));
+export const CODEX_SESSION_CONFIG_FIELDS = ['permissionMode', 'effort'];
 const MAX_CODEX_SKILL_COMMAND_CHOICES = 50;
 export function buildCodexSkillCommands(skills) {
     return skills
@@ -115,7 +126,7 @@ export function buildCodexSkillCommands(skills) {
         };
     });
 }
-function buildCodexRuntimeDescriptor(input) {
+export function buildCodexRuntimeDescriptor(input) {
     const commands = [
         {
             id: 'runtime-status',
@@ -135,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);
@@ -224,7 +249,7 @@ async function loadSessionConfig(conversationId, agentId) {
     return loadHostSessionConfig({
         conversationId,
         agentId,
-        extraStringFields: ['permissionMode', 'effort'],
+        extraStringFields: CODEX_SESSION_CONFIG_FIELDS,
     });
 }
 function resolveSessionExecutionMode(config) {
@@ -1731,6 +1756,7 @@ export async function main() {
             defaultPermissionMode: codexPermissionEnvelope.defaultPermissionMode,
             presentation: runtimePresentation,
             supportsPlanMode: useAppServer,
+            supportsCompact: useAppServer,
             supportsRichCards: useAppServer,
             skills: codexSkills,
         }),
@@ -1827,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,
@@ -1837,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.
@@ -1872,18 +1927,19 @@ export async function main() {
                 runtime: runtimeDescriptor,
                 workspaceOptions,
                 defaultCwd: workingDir,
-                extraSessionConfigFields: ['permissionMode'],
+                extraSessionConfigFields: CODEX_SESSION_CONFIG_FIELDS,
                 liveSessionConfigByConversation: new Map(Array.from(sessions.values()).map((session) => {
                     const workspaceId = resolveWorkspaceIdForBaseCwd(session.environment.baseCwd);
                     return [
                         session.conversationId,
-                        {
-                            ...(session.state.model ? { model: session.state.model } : {}),
-                            ...(session.state.permissionMode ? { permissionMode: session.state.permissionMode } : {}),
-                            ...(workspaceId ? { workspaceId } : {}),
+                        buildCodexLiveSessionConfig({
+                            model: session.state.model,
+                            permissionMode: session.state.permissionMode,
+                            effort: session.state.effort,
+                            workspaceId,
                             executionMode: session.environment.mode,
                             executionBranch: session.environment.branch ?? null,
-                        },
+                        }),
                     ];
                 })),
             }).catch((error) => {

package/package.json

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