@canonmsg/codex-plugin 0.18.2 → 0.18.4

package/dist/host.d.ts

@@ -1,2 +1,19 @@
 #!/usr/bin/env node
+/** GPT reasoning-effort levels, applied next turn via model_reasoning_effort. */
+export declare const CODEX_EFFORT_OPTIONS: readonly [{
+    readonly value: "minimal";
+    readonly label: "Minimal";
+}, {
+    readonly value: "low";
+    readonly label: "Low";
+}, {
+    readonly value: "medium";
+    readonly label: "Medium";
+}, {
+    readonly value: "high";
+    readonly label: "High";
+}, {
+    readonly value: "xhigh";
+    readonly label: "Extra high";
+}];
 export declare function main(): Promise<void>;

package/dist/host.js

@@ -5,6 +5,7 @@ import { spawnSync } from 'node:child_process';
 import { dirname } from 'node:path';
 import { parseArgs } from 'node:util';
 import { getCodexImagePath, materializeMessageMedia, materializeReplyContextMedia, sendMediaFileMessage, } from '@canonmsg/agent-sdk';
+import { buildTurnArtifactContextLine, ensureTurnArtifactDir, flushTurnArtifacts, } from '@canonmsg/coding-agent-host';
 import { RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildRuntimeCardOutcome, buildPlanApprovalRequest, resolveQuestionAllowOther, buildCanonTurnContextV2, buildConfiguredWorkspaceOptionsWithRoots, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, createConversationMetadataLoader, createRuntimeStatePublisher, createTypingStatusPublisher, EXECUTION_ENVIRONMENT_MODES, ExecutionEnvironmentError, CanonClient, CanonStream, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, FINAL_MESSAGE_HANDOFF_MS, getActiveProfileLock, initRTDBAuth, buildLocalRuntimeId, heartbeatLocalRuntimeEntry, loadRuntimeSessionState, markLocalRuntimeStopped, normalizeTurnMetadata, parseRuntimeCardV1, prepareConversationEnvironment, loadHostSessionConfig, releaseConversationEnvironment, resolveCanonAgent, CanonApiError, sendMessageWithRetry, sendMessageWithRetryChunked, shouldTriggerAgentTurn, saveRuntimeSessionState, buildBoundedTurnTrail, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, renderCanonTurnBriefPrompt, resolveHostWorkspaceCwd, upsertLocalRuntimeEntry, } from '@canonmsg/core';
 import { decideAutoReply, } from './inbound-policy.js';
 import { CodexConversationAdapter, } from './adapter.js';
@@ -16,7 +17,6 @@ import { detectCodexCliVersion } from './codex-cli-version.js';
 import { buildCodexModelGuardMessage, formatCodexTurnFailure, isRecoverableCodexThreadError, } from './error-format.js';
 import { startCodexStreamInBackground } from './host-lifecycle.js';
 import { createCodexControlPoller } from './control-channel.js';
-import { buildOutboxContextLine, ensureOutboxDir, flushOutbox, resolveOutboxDir, } from './outbox.js';
 import { runCli } from './cli-entry.js';
 import { collectMissedInboundMessages, STARTUP_RECOVERY_MAX_MESSAGES, STARTUP_RECOVERY_PAGE_SIZE, } from './startup-recovery.js';
 import { beginCommandBlock, claimCommandBlock, createCommandBlockTracker, } from './turn-activity.js';
@@ -69,11 +69,12 @@ let workspaceOptions = [];
 let workspaceRoots = [];
 let workspaceRootMetadata = [];
 /** GPT reasoning-effort levels, applied next turn via model_reasoning_effort. */
-const CODEX_EFFORT_OPTIONS = [
+export const CODEX_EFFORT_OPTIONS = [
     { value: 'minimal', label: 'Minimal' },
     { value: 'low', label: 'Low' },
     { value: 'medium', label: 'Medium' },
     { value: 'high', label: 'High' },
+    { value: 'xhigh', label: 'Extra high' },
 ];
 const CODEX_EFFORT_VALUES = new Set(CODEX_EFFORT_OPTIONS.map((option) => option.value));
 function buildCodexRuntimeDescriptor(input) {
@@ -888,7 +889,6 @@ export async function main() {
                 };
                 sessions.set(conversationId, session);
                 await controlPoller.baseline([conversationId]);
-                ensureOutboxDir(sessionCwd).catch((error) => console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Failed to create media outbox:`, error));
                 console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Environment → ${environment.mode} (${sessionCwd})`);
                 writeState(session);
                 writeTurn(session);
@@ -1288,7 +1288,6 @@ export async function main() {
             activeSelfContextId,
             provenance: hydrated.provenance,
             replyContext,
-            sessionContextLines: [buildOutboxContextLine(session.cwd)],
             message: input.message,
         });
         if (session.running && deliveryIntent === 'interrupt') {
@@ -1301,16 +1300,13 @@ export async function main() {
         }
         enqueuePrompt(session, prompt, deliveryIntent, false, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode);
     }
-    /**
-     * Turn-end media outbox flush (see ./outbox.ts for the convention). Never
-     * throws: upload failures are logged and the files stay in place for a
-     * later turn.
-     */
-    async function flushSessionOutbox(session) {
+    async function routeSessionArtifacts(session, artifactDir) {
+        if (!artifactDir)
+            return;
         const logPrefix = `[canon-codex] [${session.conversationId.slice(0, 8)}]`;
         try {
-            const result = await flushOutbox({
-                outboxDir: resolveOutboxDir(session.cwd),
+            const result = await flushTurnArtifacts({
+                artifactDir,
                 send: (file) => sendMediaFileMessage(client, session.conversationId, file.path, '', {
                     ...(session.activeSelfContextId ? { selfContextId: session.activeSelfContextId } : {}),
                     metadata: {
@@ -1324,20 +1320,20 @@ export async function main() {
                 }),
             });
             for (const entry of result.sent) {
-                console.error(`${logPrefix} Sent outbox file ${entry.file.fileName} (${entry.messageId})`
-                    + (entry.removeFailed ? ' — removal failed; it may resend next turn' : ''));
+                console.error(`${logPrefix} Routed artifact ${entry.file.fileName} (${entry.messageId})`
+                    + (entry.removeFailed ? '; removal failed, so it may resend later' : ''));
             }
             for (const failure of result.failed) {
-                console.error(`${logPrefix} Outbox upload failed for ${failure.file.fileName}; left in place: ${failure.error}`);
+                console.error(`${logPrefix} Artifact upload failed for ${failure.file.fileName}; left in place: ${failure.error}`);
             }
             for (const skipped of result.skipped) {
-                if (skipped.reason === 'too-large' || skipped.reason === 'file-cap') {
-                    console.error(`${logPrefix} Outbox skipped ${skipped.fileName} (${skipped.reason}); left in place`);
+                if (skipped.reason === 'too-large' || skipped.reason === 'file-cap' || skipped.reason === 'unsupported') {
+                    console.error(`${logPrefix} Artifact skipped ${skipped.fileName} (${skipped.reason})`);
                 }
             }
         }
         catch (error) {
-            console.error(`${logPrefix} Outbox flush failed:`, error instanceof Error ? error.message : error);
+            console.error(`${logPrefix} Artifact routing failed:`, error instanceof Error ? error.message : error);
         }
     }
     async function runNextTurn(session) {
@@ -1365,7 +1361,19 @@ export async function main() {
         // Status-only seed: 'thinking' renders as a working filament row on the
         // clients; text here would be bubbled as speech (v4 register rule).
         writeCodexStreaming(session, '', 'thinking');
+        let artifactDir = null;
+        let artifactsRouted = false;
+        const routeArtifactsOnce = async () => {
+            if (artifactsRouted)
+                return;
+            artifactsRouted = true;
+            await routeSessionArtifacts(session, artifactDir);
+        };
         try {
+            const turnId = session.currentTurnId ?? randomUUID();
+            session.currentTurnId = turnId;
+            artifactDir = await ensureTurnArtifactDir(session.cwd, turnId);
+            const turnPrompt = `${nextTurn.prompt}\n\n${buildTurnArtifactContextLine(artifactDir)}`;
             const modelGuard = buildCodexModelGuardMessage(session.state.model, codexCliStatus);
             if (modelGuard) {
                 throw new ExecutionEnvironmentError(modelGuard, modelGuard);
@@ -1469,7 +1477,7 @@ export async function main() {
                 clearStoredThreadId(runtimeId, agentId, session.conversationId, session.environment.baseCwd, session.environment.mode);
                 session.adapter.clearThreadId();
             };
-            const runTurnOnce = () => session.adapter.runTurn(nextTurn.prompt, handleCodexEvent, logCodexLine, turnImagePaths, turnMediaAddDirs, {
+            const runTurnOnce = () => session.adapter.runTurn(turnPrompt, handleCodexEvent, logCodexLine, turnImagePaths, turnMediaAddDirs, {
                 planMode: nextTurn.planMode,
                 onServerRequest: (request) => handleCodexServerRequest(session, request),
             });
@@ -1486,12 +1494,8 @@ export async function main() {
             if (result.threadId && !session.resetRequested) {
                 saveStoredThreadId(runtimeId, agentId, session.conversationId, session.environment.baseCwd, result.threadId, session.environment.mode, session.policyFingerprint);
             }
-            // Turn-end outbox flush — media lands before the final text reply.
-            // Interrupted turns keep their files for the next completed turn.
-            if (!result.interrupted) {
-                await flushSessionOutbox(session);
-            }
             if (!result.interrupted && result.finalMessage && nextTurn.planMode) {
+                await routeArtifactsOnce();
                 const planApproval = buildPlanApprovalRequest(session.currentTurnId ?? randomUUID(), 'Plan ready for review.', {
                     responseUserId: ownerId ?? undefined,
                     title: 'Codex Plan',
@@ -1513,6 +1517,7 @@ export async function main() {
                 if (isRecoverableCodexThreadError(result.errorText)) {
                     clearStoredThread();
                 }
+                await routeArtifactsOnce();
                 const turnTrail = buildFinalTurnTrail(session);
                 await sendMessageWithRetryChunked(client, session.conversationId, result.finalMessage, {
                     messageId: buildCodexMessageId(session, 'final'),
@@ -1530,6 +1535,7 @@ export async function main() {
                 console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Sent reply (${result.finalMessage.length} chars)`);
             }
             else if (!result.interrupted && result.exitCode && result.exitCode !== 0) {
+                await routeArtifactsOnce();
                 const userVisibleError = formatCodexTurnFailure(result.errorText);
                 session.state.lastError = userVisibleError;
                 writeState(session);
@@ -1552,6 +1558,7 @@ export async function main() {
                 await handoffFinalMessage(session.conversationId);
             }
             else if (!result.interrupted) {
+                await routeArtifactsOnce();
                 await handoffFinalMessage(session.conversationId);
             }
             else if (result.interrupted) {
@@ -1571,6 +1578,7 @@ export async function main() {
                     : `The Codex host failed during the turn: ${error instanceof Error ? error.message : String(error)}`;
             session.state.lastError = message;
             writeState(session);
+            await routeArtifactsOnce();
             await sendMessageWithRetryChunked(client, session.conversationId, message, {
                 messageId: buildCodexMessageId(session, 'failure'),
                 ...(session.activeSelfContextId
@@ -1816,7 +1824,7 @@ export async function main() {
                         {
                             id: 'mediaOut',
                             label: 'Media out',
-                            value: 'Turn-end outbox',
+                            value: 'Explicit turn artifact directory',
                         },
                     ],
                     execution: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.18.2",
+  "version": "0.18.4",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/index.js",
@@ -21,7 +21,7 @@
     "scripts"
   ],
   "scripts": {
-    "prepare:workspace-deps": "node ../../scripts/run-workspace-prep.mjs ../core ../agent-sdk",
+    "prepare:workspace-deps": "node ../../scripts/run-workspace-prep.mjs ../core ../agent-sdk ../coding-agent-host",
     "build": "npm run prepare:workspace-deps && node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
     "dev": "npm run prepare:workspace-deps && tsc --watch",
     "smoke": "node scripts/smoke-test.mjs",
@@ -30,6 +30,7 @@
   },
   "dependencies": {
     "@canonmsg/agent-sdk": "^3.2.3",
+    "@canonmsg/coding-agent-host": "^0.2.0",
     "@canonmsg/core": "^2.6.0"
   },
   "engines": {

package/dist/outbox.d.ts

@@ -1,83 +0,0 @@
-/**
- * Turn-end media outbox for Canon coding hosts.
- *
- * The host advertises a per-conversation outbox directory inside the session
- * working directory (`<cwd>/.canon/outbox/`). When the runtime wants a file
- * (screenshot, plot, artifact) delivered to the Canon conversation it writes
- * the file there — an explicit channel, never inferred from reply prose. At
- * turn end the host scans the outbox, uploads each regular file as a Canon
- * media attachment, and removes files that were delivered. Failed uploads
- * stay in place for a later turn; subdirectories, symlinks, and dotfiles are
- * ignored.
- *
- * This module is intentionally identical in packages/claude-code-plugin and
- * packages/codex-plugin — keep both copies in sync (future consolidation
- * candidate).
- */
-export declare const OUTBOX_MAX_FILES_PER_TURN = 8;
-export declare const OUTBOX_MAX_FILE_BYTES: number;
-export interface OutboxFile {
-    path: string;
-    fileName: string;
-    sizeBytes: number;
-}
-export type OutboxSkipReason = 'not-regular-file' | 'hidden' | 'too-large' | 'file-cap';
-export interface OutboxScanResult {
-    /** Regular files eligible for upload this turn, ordered by file name. */
-    files: OutboxFile[];
-    skipped: Array<{
-        fileName: string;
-        reason: OutboxSkipReason;
-    }>;
-}
-export interface OutboxFlushResult {
-    sent: Array<{
-        file: OutboxFile;
-        messageId: string;
-        removeFailed?: true;
-    }>;
-    failed: Array<{
-        file: OutboxFile;
-        error: string;
-    }>;
-    skipped: OutboxScanResult['skipped'];
-}
-export declare function resolveOutboxDir(sessionCwd: string): string;
-/**
- * Create the outbox directory for a session and drop a `.gitignore` into the
- * host-managed `.canon/` dir (only when absent) so outbox state never shows
- * up as untracked dirt inside project checkouts or conversation worktrees.
- */
-export declare function ensureOutboxDir(sessionCwd: string): Promise<string>;
-/**
- * The one terse paragraph injected into the runtime's Canon context so the
- * agent knows the outbox exists. Hosts may append their own extra sentence
- * (e.g. an immediate-send tool) but must not paraphrase the convention.
- */
-export declare function buildOutboxContextLine(sessionCwd: string): string;
-/**
- * Discover the outbox files eligible for upload this turn. A missing outbox
- * directory is an empty result. Entries are ordered by file name so multi-file
- * turns deliver deterministically; everything past the per-turn cap (or over
- * the size cap) is left in place and reported as skipped.
- */
-export declare function scanOutbox(outboxDir: string, options?: {
-    maxFiles?: number;
-    maxFileBytes?: number;
-}): Promise<OutboxScanResult>;
-/**
- * Upload-and-consume pass over the outbox. Each eligible file is handed to
- * `send`; on success the file is removed (consumed), on failure it is left in
- * place for a later turn. A failed removal after a successful send is still
- * reported as sent (flagged `removeFailed`) so callers can warn about a
- * potential duplicate next turn instead of re-reporting a delivery failure.
- */
-export declare function flushOutbox(input: {
-    outboxDir: string;
-    send: (file: OutboxFile) => Promise<{
-        messageId: string;
-    }>;
-    maxFiles?: number;
-    maxFileBytes?: number;
-    remove?: (path: string) => Promise<void>;
-}): Promise<OutboxFlushResult>;

package/dist/outbox.js

@@ -1,132 +0,0 @@
-/**
- * Turn-end media outbox for Canon coding hosts.
- *
- * The host advertises a per-conversation outbox directory inside the session
- * working directory (`<cwd>/.canon/outbox/`). When the runtime wants a file
- * (screenshot, plot, artifact) delivered to the Canon conversation it writes
- * the file there — an explicit channel, never inferred from reply prose. At
- * turn end the host scans the outbox, uploads each regular file as a Canon
- * media attachment, and removes files that were delivered. Failed uploads
- * stay in place for a later turn; subdirectories, symlinks, and dotfiles are
- * ignored.
- *
- * This module is intentionally identical in packages/claude-code-plugin and
- * packages/codex-plugin — keep both copies in sync (future consolidation
- * candidate).
- */
-import { mkdir, readdir, stat, unlink, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-export const OUTBOX_MAX_FILES_PER_TURN = 8;
-export const OUTBOX_MAX_FILE_BYTES = 25 * 1024 * 1024;
-export function resolveOutboxDir(sessionCwd) {
-    return join(sessionCwd, '.canon', 'outbox');
-}
-/**
- * Create the outbox directory for a session and drop a `.gitignore` into the
- * host-managed `.canon/` dir (only when absent) so outbox state never shows
- * up as untracked dirt inside project checkouts or conversation worktrees.
- */
-export async function ensureOutboxDir(sessionCwd) {
-    const dir = resolveOutboxDir(sessionCwd);
-    await mkdir(dir, { recursive: true });
-    try {
-        // The `*` pattern ignores everything under .canon, including this file.
-        await writeFile(join(sessionCwd, '.canon', '.gitignore'), '*\n', { flag: 'wx' });
-    }
-    catch {
-        // Already present (or unwritable) — never block session startup on it.
-    }
-    return dir;
-}
-/**
- * The one terse paragraph injected into the runtime's Canon context so the
- * agent knows the outbox exists. Hosts may append their own extra sentence
- * (e.g. an immediate-send tool) but must not paraphrase the convention.
- */
-export function buildOutboxContextLine(sessionCwd) {
-    const maxMb = Math.floor(OUTBOX_MAX_FILE_BYTES / (1024 * 1024));
-    return `Media outbox: to deliver a file (screenshot, plot, artifact) to this Canon conversation, write it into ${resolveOutboxDir(sessionCwd)} — when your turn ends the host uploads each regular file there as a chat attachment and then deletes it. Limits: ${OUTBOX_MAX_FILES_PER_TURN} files per turn and ${maxMb}MB per file; subdirectories, symlinks, and dotfiles are ignored.`;
-}
-/**
- * Discover the outbox files eligible for upload this turn. A missing outbox
- * directory is an empty result. Entries are ordered by file name so multi-file
- * turns deliver deterministically; everything past the per-turn cap (or over
- * the size cap) is left in place and reported as skipped.
- */
-export async function scanOutbox(outboxDir, options) {
-    const maxFiles = options?.maxFiles ?? OUTBOX_MAX_FILES_PER_TURN;
-    const maxFileBytes = options?.maxFileBytes ?? OUTBOX_MAX_FILE_BYTES;
-    let entries;
-    try {
-        entries = await readdir(outboxDir, { withFileTypes: true });
-    }
-    catch (error) {
-        if (error.code === 'ENOENT') {
-            return { files: [], skipped: [] };
-        }
-        throw error;
-    }
-    const files = [];
-    const skipped = [];
-    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-        // `readdir` does not follow symlinks, so a symlinked file reports
-        // isSymbolicLink(), not isFile() — links and directories both land here.
-        if (!entry.isFile()) {
-            skipped.push({ fileName: entry.name, reason: 'not-regular-file' });
-            continue;
-        }
-        if (entry.name.startsWith('.')) {
-            skipped.push({ fileName: entry.name, reason: 'hidden' });
-            continue;
-        }
-        const path = join(outboxDir, entry.name);
-        const info = await stat(path);
-        if (info.size > maxFileBytes) {
-            skipped.push({ fileName: entry.name, reason: 'too-large' });
-            continue;
-        }
-        if (files.length >= maxFiles) {
-            skipped.push({ fileName: entry.name, reason: 'file-cap' });
-            continue;
-        }
-        files.push({ path, fileName: entry.name, sizeBytes: info.size });
-    }
-    return { files, skipped };
-}
-/**
- * Upload-and-consume pass over the outbox. Each eligible file is handed to
- * `send`; on success the file is removed (consumed), on failure it is left in
- * place for a later turn. A failed removal after a successful send is still
- * reported as sent (flagged `removeFailed`) so callers can warn about a
- * potential duplicate next turn instead of re-reporting a delivery failure.
- */
-export async function flushOutbox(input) {
-    const { files, skipped } = await scanOutbox(input.outboxDir, {
-        ...(input.maxFiles != null ? { maxFiles: input.maxFiles } : {}),
-        ...(input.maxFileBytes != null ? { maxFileBytes: input.maxFileBytes } : {}),
-    });
-    const remove = input.remove ?? ((path) => unlink(path));
-    const sent = [];
-    const failed = [];
-    for (const file of files) {
-        let messageId;
-        try {
-            ({ messageId } = await input.send(file));
-        }
-        catch (error) {
-            failed.push({
-                file,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            continue;
-        }
-        try {
-            await remove(file.path);
-            sent.push({ file, messageId });
-        }
-        catch {
-            sent.push({ file, messageId, removeFailed: true });
-        }
-    }
-    return { sent, failed, skipped };
-}