@canonmsg/codex-plugin 0.29.3 → 0.29.4

package/dist/adapter.d.ts

@@ -45,6 +45,8 @@ export interface CodexServerRequest {
     params: Record<string, unknown>;
 }
 export interface CodexRunTurnOptions {
+    /** Original human text, before Canon adds conversation/reply context. */
+    skillInvocationText?: string;
     planMode?: boolean;
     onServerRequest?: (request: CodexServerRequest) => Promise<unknown>;
 }

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

@@ -36,6 +36,7 @@ export declare class CodexAppServerAdapter {
     private threadId;
     private loadedThreadId;
     private resolvedModel;
+    private observedSettings;
     private resolvedReasoningEffort;
     private currentTurnId;
     private requestSeq;
@@ -67,6 +68,10 @@ export declare class CodexAppServerAdapter {
     });
     getThreadId(): string | null;
     getResolvedModel(): string | null;
+    getObservedSettings(): Readonly<{
+        model?: string;
+        effort?: string;
+    }>;
     getResolvedReasoningEffort(): string | null;
     clearThreadId(): void;
     setModel(model: string | null): void;

package/dist/app-server-adapter.js

@@ -17,6 +17,8 @@ export class CodexAppServerAdapter {
     threadId;
     loadedThreadId = null;
     resolvedModel = null;
+    // Public observations never inherit requested settings or fallback defaults.
+    observedSettings = {};
     resolvedReasoningEffort;
     currentTurnId = null;
     requestSeq = 1;
@@ -53,16 +55,21 @@ export class CodexAppServerAdapter {
     getResolvedModel() {
         return this.resolvedModel ?? this.model;
     }
+    getObservedSettings() {
+        return { ...this.observedSettings };
+    }
     getResolvedReasoningEffort() {
         return this.resolvedReasoningEffort ?? this.reasoningEffort;
     }
     clearThreadId() {
+        this.observedSettings = {};
         this.threadId = null;
         this.loadedThreadId = null;
         this.resolvedModel = null;
         this.resolvedReasoningEffort = this.reasoningEffort;
     }
     setModel(model) {
+        this.observedSettings = {};
         this.model = model;
         this.resolvedModel = model;
     }
@@ -78,6 +85,7 @@ export class CodexAppServerAdapter {
         const next = effort && effort.trim() ? effort.trim() : null;
         if (next === this.reasoningEffort && next === this.resolvedReasoningEffort)
             return;
+        this.observedSettings = { model: this.observedSettings.model };
         this.reasoningEffort = next;
         this.resolvedReasoningEffort = next;
         if (this.threadId && this.loadedThreadId === this.threadId) {
@@ -110,6 +118,7 @@ export class CodexAppServerAdapter {
         return await this.sendRequest(method, params);
     }
     close() {
+        this.observedSettings = {};
         this.child?.kill('SIGTERM');
         this.child = null;
         this.initialized = false;
@@ -171,7 +180,7 @@ export class CodexAppServerAdapter {
             turnPromise.catch(() => { });
             const turnStarted = await this.sendRequest('turn/start', {
                 threadId: this.threadId,
-                input: await this.buildTurnInput(prompt, imagePaths),
+                input: await this.buildTurnInput(prompt, imagePaths, options.skillInvocationText),
                 ...(this.model ? { model: this.model } : {}),
                 ...this.sandboxPolicyPayload(_extraAddDirs),
                 collaborationMode: {
@@ -216,7 +225,9 @@ export class CodexAppServerAdapter {
     }
     rememberResolvedModel(result) {
         const thread = result.thread;
-        this.resolvedModel = readString(thread, 'model') ?? readString(result, 'model') ?? this.resolvedModel;
+        const model = readString(thread, 'model') ?? readString(result, 'model');
+        this.observedSettings = { ...this.observedSettings, model: model ?? undefined };
+        this.resolvedModel = model ?? this.resolvedModel;
     }
     sandboxPolicyPayload(extraAddDirs) {
         if (this.bypassApprovalsAndSandbox || this.sandbox === 'danger-full-access') {
@@ -290,22 +301,27 @@ export class CodexAppServerAdapter {
         } while (cursor);
         return models;
     }
-    async buildTurnInput(prompt, imagePaths) {
-        const skillPrompt = parseSkillSlashPrompt(prompt);
+    async buildTurnInput(prompt, imagePaths, skillInvocationText) {
+        const skillPrompt = parseSkillSlashPrompt(skillInvocationText ?? prompt);
         const input = [];
         if (skillPrompt) {
             const skills = await this.listSkills().catch(() => []);
             const selected = skills.find((skill) => skill.name.toLowerCase() === skillPrompt.name.toLowerCase());
             if (selected) {
                 input.push({ type: 'skill', name: selected.name, path: selected.path });
-                if (skillPrompt.prompt.trim()) {
-                    input.push({ type: 'text', text: skillPrompt.prompt, text_elements: [] });
+                // Resolve the native skill from the actual message, retaining the
+                // framed prompt as context instead of parsing quoted/history text.
+                const text = skillInvocationText === undefined ? skillPrompt.prompt : prompt;
+                if (text.trim()) {
+                    input.push({ type: 'text', text, text_elements: [] });
                 }
             }
             else {
                 input.push({
                     type: 'text',
-                    text: `$${skillPrompt.name}${skillPrompt.prompt.trim() ? ` ${skillPrompt.prompt.trim()}` : ''}`,
+                    text: skillInvocationText === undefined
+                        ? `$${skillPrompt.name}${skillPrompt.prompt.trim() ? ` ${skillPrompt.prompt.trim()}` : ''}`
+                        : prompt,
                     text_elements: [],
                 });
             }
@@ -333,6 +349,7 @@ export class CodexAppServerAdapter {
                 this.currentOnLog?.(trimmed);
         });
         child.on('close', (code) => {
+            this.observedSettings = {};
             const message = `Codex app-server exited${code === null ? '' : ` with code ${code}`}`;
             this.initialized = false;
             this.child = null;
@@ -428,6 +445,7 @@ export class CodexAppServerAdapter {
             const settings = isRecord(params.threadSettings) ? params.threadSettings : {};
             const model = readString(settings, 'model') ?? null;
             const effort = readString(settings, 'effort') ?? null;
+            this.observedSettings = { model: model ?? undefined, effort: effort ?? undefined };
             this.resolvedModel = model ?? this.resolvedModel;
             this.resolvedReasoningEffort = effort;
             this.currentOnEvent?.({ type: 'settings.updated', model, effort });
@@ -435,6 +453,7 @@ export class CodexAppServerAdapter {
         }
         if (method === 'model/rerouted') {
             const model = readString(params, 'toModel') ?? null;
+            this.observedSettings = { model: model ?? undefined };
             this.resolvedModel = model ?? this.resolvedModel;
             this.currentOnEvent?.({
                 type: 'settings.updated',

package/dist/host.d.ts

@@ -1,10 +1,13 @@
 #!/usr/bin/env node
 import { type TurnArtifactRoutingDecision, type TurnArtifactRoutingMode, type RecoveryCheckpointTracker } from '@canonmsg/coding-agent-host';
-import { type CanonRuntimeCommandDescriptor, type CanonRuntimeDescriptor, type CanonRuntimePresentationPolicy, type ExecutionEnvironmentMode, type PreparedExecutionEnvironment, type WorkspaceOption, type CanonWorkspaceRootMetadata, type RuntimeStreamingPayload, type TurnLifecycleState, type TurnOutputBlock, type TurnVerbosity, type TurnVerbosityConfig } from '@canonmsg/core';
-import { type CodexSandboxMode } from './adapter.js';
-import { type CodexSkillMetadata } from './app-server-adapter.js';
+import { type CanonRuntimeCommandDescriptor, type CanonRuntimeDescriptor, type CanonRuntimeFact, type CanonRuntimePresentationPolicy, type ExecutionEnvironmentMode, type PreparedExecutionEnvironment, type WorkspaceOption, type CanonWorkspaceRootMetadata, type DeliveryIntent, type RuntimeStreamingPayload, type TurnLifecycleState, type TurnOutputBlock, type TurnVerbosity, type TurnVerbosityConfig } from '@canonmsg/core';
+import type { AgentReplyAuthorityV1 } from '@canonmsg/backend-contracts';
+import { CodexConversationAdapter, type CodexSandboxMode } from './adapter.js';
+import { CodexAppServerAdapter, type CodexSkillMetadata } from './app-server-adapter.js';
 import { deriveCodexPermissionEnvelope } from './permission-mode.js';
+import { type CommandBlockTracker } from './turn-activity.js';
 import { type CodexControlOption } from './model-catalog.js';
+type CodexAdapter = CodexConversationAdapter | CodexAppServerAdapter;
 interface HostSessionState {
     lastError?: string;
     model?: string;
@@ -21,6 +24,63 @@ export declare function buildCodexInitialSessionState(input: {
     permissionMode?: string;
     effort?: string | null;
 }): HostSessionState;
+type ArtifactRoutingMode = 'workspace-generated' | 'disabled';
+interface Session {
+    conversationId: string;
+    cwd: string;
+    environment: PreparedExecutionEnvironment;
+    adapter: CodexAdapter;
+    queue: Array<{
+        prompt: string;
+        skillInvocationText?: string;
+        planMode?: boolean;
+        intent: DeliveryIntent;
+        sourceMessageId?: string | null;
+        markAccepted?: boolean;
+        imagePaths?: string[];
+        mediaAddDirs?: string[];
+        artifactRoutingMode?: ArtifactRoutingMode;
+        canUseCodexAppTools?: boolean;
+        /**
+         * Resolved when this message arrived and carried here, so a prompt that
+         * waits in the queue still runs under the answer it arrived with. Absent on
+         * a continuation prompt (a plan-review result), which inherits whatever the
+         * conversation last resolved.
+         */
+        turnVerbosity?: TurnVerbosity;
+        requestingUserId: string | null;
+        replyAuthority: AgentReplyAuthorityV1 | null;
+    }>;
+    running: boolean;
+    state: HostSessionState;
+    policyFingerprint: string;
+    turnState: TurnLifecycleState;
+    currentTurnId: string | null;
+    currentTurnOpenedAt: number | null;
+    currentTurnUpdatedAt: number | null;
+    currentTurnCanUseCodexAppTools: boolean;
+    currentReplyAuthority: AgentReplyAuthorityV1 | null;
+    /** Cancels Canon interactions created by the currently running Codex turn. */
+    currentTurnAbortController: AbortController | null;
+    /**
+     * The verbosity the RUNNING turn was opened with. Promoted off the queue
+     * entry at `runNextTurn` and never re-read mid-turn, so the live writer, the
+     * turn-state writer and the final's trail cannot disagree with each other.
+     */
+    turnVerbosity: TurnVerbosity;
+    /** The running turn called `no_reply`: end it without posting anything. */
+    currentTurnSilenced: boolean;
+    activeSelfContextId: string | null;
+    lastAcceptedIntent: DeliveryIntent | null;
+    resetRequested: boolean;
+    lastActivity: number;
+    typingKeepaliveTimer: ReturnType<typeof setInterval> | null;
+    closed: boolean;
+    turnLiveText: string;
+    turnBlocks: TurnOutputBlock[];
+    turnCommandBlocks: CommandBlockTracker;
+}
+export declare function buildCodexSessionFacts(session?: Pick<Session, 'closed' | 'adapter'>): CanonRuntimeFact[];
 export declare function createCodexRecoveryCheckpointTracker(persist: (messageId: string) => boolean): RecoveryCheckpointTracker;
 /** Conservative fallback used only when native app-server discovery is unavailable. */
 export declare const CODEX_EFFORT_OPTIONS: readonly CodexControlOption[];

package/dist/host.js

@@ -69,6 +69,23 @@ export function buildCodexInitialSessionState(input) {
         state: 'idle',
     };
 }
+export function buildCodexSessionFacts(session) {
+    if (!session || session.closed)
+        return [];
+    const adapter = session.adapter;
+    const appServer = adapter instanceof CodexAppServerAdapter;
+    const facts = [{
+            id: 'runtime', label: 'Runtime', value: appServer ? 'Codex app-server' : 'Codex CLI', group: 'runtime',
+        }];
+    if (appServer) {
+        const observed = adapter.getObservedSettings();
+        if (observed.model)
+            facts.push({ id: 'model', label: 'Model', value: observed.model, group: 'model' });
+        if (observed.effort)
+            facts.push({ id: 'reasoning', label: 'Reasoning', value: observed.effort, group: 'model' });
+    }
+    return facts;
+}
 const MAX_SESSIONS = 12;
 export function createCodexRecoveryCheckpointTracker(persist) {
     return createRecoveryCheckpointTracker(persist);
@@ -133,10 +150,10 @@ export function buildCodexRuntimeDescriptor(input) {
     const commands = [
         {
             id: 'runtime-status',
-            label: 'Runtime status',
-            description: 'Open Codex runtime details.',
+            label: 'Session info',
+            description: 'Open Canon session information.',
             primitive: 'runtime.status',
-            aliases: ['status'],
+            aliases: ['session-info'],
             category: 'details',
             placements: ['composer_slash', 'command_palette'],
             availability: ['always'],
@@ -1338,6 +1355,7 @@ export async function main() {
     function enqueuePrompt(session, prompt, intent = 'queue', toFront = false, sourceMessageId, markAccepted = false, imagePaths = [], mediaAddDirs = [], planMode = false, turn = {}) {
         const nextPrompt = {
             prompt,
+            skillInvocationText: turn.skillInvocationText,
             intent,
             sourceMessageId,
             markAccepted,
@@ -1884,6 +1902,7 @@ export async function main() {
         if (session.running && deliveryIntent === 'interrupt') {
             enqueuePrompt(session, prompt, deliveryIntent, true, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode, {
                 ...resolveCodexTurnModes(participantContext, input.message),
+                skillInvocationText: input.message.senderType === 'human' ? input.message.text ?? undefined : undefined,
                 replyAuthority: input.replyAuthority ?? null,
             });
             console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Interrupting current turn for explicit human send-now`);
@@ -1895,6 +1914,7 @@ export async function main() {
         }
         enqueuePrompt(session, prompt, deliveryIntent, false, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode, {
             ...resolveCodexTurnModes(participantContext, input.message),
+            skillInvocationText: input.message.senderType === 'human' ? input.message.text ?? undefined : undefined,
             replyAuthority: input.replyAuthority ?? null,
         });
     }
@@ -2126,6 +2146,7 @@ export async function main() {
             };
             const runTurnOnce = () => session.adapter.runTurn(turnPrompt, handleCodexEvent, logCodexLine, turnImagePaths, turnMediaAddDirs, {
                 planMode: nextTurn.planMode,
+                skillInvocationText: nextTurn.skillInvocationText,
                 onServerRequest: (request) => handleCodexServerRequest(session, request, nextTurn.requestingUserId ?? null, nextTurn.sourceMessageId ?? null),
             });
             let result = await runTurnOnce();
@@ -2584,12 +2605,9 @@ export async function main() {
                 return;
             await runtimeState.writeRuntimeInfo(conversationId, {
                 surfaceMode: 'host',
-                descriptor: {
-                    coreControls: [],
-                    supportsInterrupt: descriptor.supportsInterrupt,
-                    supportsInputInterrupt: descriptor.supportsInputInterrupt,
-                    streamingTextMode: descriptor.streamingTextMode,
-                },
+                // The shared publisher sanitizes configuration while retaining commands.
+                descriptor,
+                facts: buildCodexSessionFacts(sessions.get(conversationId)),
             });
         }));
         const failure = results.find((result) => result.status === 'rejected');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.29.3",
+  "version": "0.29.4",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/index.js",
@@ -32,7 +32,7 @@
     "@canonmsg/agent-sdk": "^10.2.1",
     "@canonmsg/agent-tools": "^0.9.0",
     "@canonmsg/coding-agent-host": "^0.7.0",
-    "@canonmsg/core": "^12.3.0",
+    "@canonmsg/core": "^12.3.1",
     "@canonmsg/rich-cards": "^0.10.4"
   },
   "engines": {