@canonmsg/codex-plugin 0.18.8 → 0.18.10

package/dist/app-server-adapter.js

@@ -534,7 +534,9 @@ function readNullableString(record, key) {
     return typeof value === 'string' && value.trim() ? value.trim() : undefined;
 }
 function parseSkillSlashPrompt(prompt) {
-    const match = prompt.trim().match(/^\/skill\s+([A-Za-z0-9:_-]+)(?:\s+([\s\S]*))?$/);
+    const trimmed = prompt.trim();
+    const match = trimmed.match(/^\$([A-Za-z0-9:_-]+)(?:\s+([\s\S]*))?$/)
+        ?? trimmed.match(/^\/skill\s+([A-Za-z0-9:_-]+)(?:\s+([\s\S]*))?$/);
     if (!match?.[1])
         return null;
     return {

package/dist/host.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { type CanonRuntimeCommandDescriptor } from '@canonmsg/core';
+import { type CanonRuntimeCommandDescriptor, type ExecutionEnvironmentMode } 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,7 @@ export declare const CODEX_EFFORT_OPTIONS: readonly [{
     readonly value: "xhigh";
     readonly label: "Extra high";
 }];
-export declare function buildCodexSkillCommand(skills: ReadonlyArray<CodexSkillMetadata>): CanonRuntimeCommandDescriptor | null;
+export declare const CODEX_SESSION_CONFIG_FIELDS: readonly ["permissionMode", "effort"];
+export declare function buildCodexSkillCommands(skills: ReadonlyArray<CodexSkillMetadata>): CanonRuntimeCommandDescriptor[];
 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,9 +95,10 @@ 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 buildCodexSkillCommand(skills) {
-    const choices = skills
+export function buildCodexSkillCommands(skills) {
+    return skills
         .filter((skill) => /^[A-Za-z0-9:_-]+$/.test(skill.name))
         .slice(0, MAX_CODEX_SKILL_COMMAND_CHOICES)
         .map((skill) => {
@@ -95,39 +106,25 @@ export function buildCodexSkillCommand(skills) {
             ?? skill.description
             ?? (skill.scope ? `${skill.scope} skill` : undefined);
         return {
-            value: skill.name,
+            id: `codex-skill-${skill.name}`,
             label: skill.displayName ?? skill.name,
+            aliases: [skill.name],
+            category: 'skill',
+            placements: ['composer_slash', 'command_palette'],
+            availability: ['always'],
+            trailingTextBehavior: 'send_as_prompt',
+            args: [
+                {
+                    id: 'prompt',
+                    label: 'Prompt',
+                    kind: 'string',
+                    captureRemaining: true,
+                },
+            ],
             ...(description ? { description } : {}),
+            dispatch: { kind: 'text_passthrough', template: `$${skill.name} {argument}` },
         };
     });
-    if (choices.length === 0)
-        return null;
-    return {
-        id: 'codex-skill',
-        label: 'Use skill',
-        description: 'Invoke one of the Codex skills available to this runtime.',
-        aliases: ['skill'],
-        category: 'skill',
-        placements: ['composer_slash', 'command_palette'],
-        availability: ['always'],
-        trailingTextBehavior: 'send_as_prompt',
-        args: [
-            {
-                id: 'skill',
-                label: 'Skill',
-                kind: 'enum',
-                required: true,
-                choices,
-            },
-            {
-                id: 'prompt',
-                label: 'Prompt',
-                kind: 'string',
-                captureRemaining: true,
-            },
-        ],
-        dispatch: { kind: 'text_passthrough', template: '/skill {args.skill} {args.prompt}' },
-    };
 }
 function buildCodexRuntimeDescriptor(input) {
     const commands = [
@@ -149,9 +146,9 @@ function buildCodexRuntimeDescriptor(input) {
         RUNTIME_STOP_ACTION,
         RUNTIME_STOP_AND_DROP_ACTION,
     ];
-    const skillCommand = input.skills?.length ? buildCodexSkillCommand(input.skills) : null;
-    if (skillCommand) {
-        commands.push(skillCommand);
+    const skillCommands = input.skills?.length ? buildCodexSkillCommands(input.skills) : [];
+    if (skillCommands.length) {
+        commands.push(...skillCommands);
     }
     const descriptor = buildFirstPartyCodingRuntimeDescriptor({
         clientType: 'codex',
@@ -238,7 +235,7 @@ async function loadSessionConfig(conversationId, agentId) {
     return loadHostSessionConfig({
         conversationId,
         agentId,
-        extraStringFields: ['permissionMode', 'effort'],
+        extraStringFields: CODEX_SESSION_CONFIG_FIELDS,
     });
 }
 function resolveSessionExecutionMode(config) {
@@ -1886,18 +1883,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.8",
+  "version": "0.18.10",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/index.js",