@canonmsg/codex-plugin 0.24.0 → 0.25.0

package/dist/host.d.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { type TurnArtifactRoutingDecision, type TurnArtifactRoutingMode } from '@canonmsg/coding-agent-host';
 import { type CanonRuntimeCommandDescriptor, type CanonRuntimeDescriptor, type CanonRuntimePresentationPolicy, type ExecutionEnvironmentMode, type WorkspaceOption, type CanonWorkspaceRootMetadata, type RuntimeStreamingPayload, type TurnLifecycleState, type TurnOutputBlock, type TurnVerbosity, type TurnVerbosityConfig } from '@canonmsg/core';
 import { type CodexSkillMetadata } from './app-server-adapter.js';
 import { type CodexControlOption } from './model-catalog.js';
@@ -136,5 +137,33 @@ export declare function planCodexStreamingWrite(input: {
  * same decision at its `text_delta` handler.
  */
 export declare function shouldStopTypingDotsOnStreamedText(turnVerbosity: TurnVerbosity): boolean;
+/**
+ * Whether this turn may post the media it generated in the workspace.
+ *
+ * Where the shared ruling (`resolveTurnArtifactRouting`) meets this host's
+ * per-turn state, and the only place silence is resolved for Codex artifacts:
+ * `silenced` here is the RAW `no_reply` sentinel, and it is weighed against the
+ * turn's own final text by `isSilentTurnSuppressed` — the same switch the final
+ * delivery reads. Flipping `DEFAULT_SILENT_TURN_PRECEDENCE` to `advisory`
+ * therefore moves a turn's text and its files together; it cannot leave Codex
+ * talking about a chart it then withholds.
+ *
+ * `finalText` is the model's own reply, never Canon's failure notice: the
+ * notice is a host diagnostic and goes out whether the turn spoke or not.
+ *
+ * Interruption is not a parameter. Codex's `result.interrupted` branch is the
+ * one completion branch that never calls the funnel, so the axis is dead on
+ * the normal paths. The known gap is the catch branch, which routes
+ * unconditionally and IS reachable after an interrupt (a hard interrupt can
+ * make `runTurn` reject rather than resolve); an interrupted turn's artifacts
+ * can still be posted alongside the failure notice there, as they always
+ * could. Claude gates that case; matching it needs an interrupt signal Codex
+ * does not currently carry into the catch without a race.
+ */
+export declare function shouldRouteCodexTurnArtifacts(input: {
+    artifactRoutingMode: TurnArtifactRoutingMode | undefined;
+    silenced: boolean;
+    finalText: string | null | undefined;
+}): TurnArtifactRoutingDecision;
 export declare function main(): Promise<void>;
 export {};

package/dist/host.js

@@ -5,8 +5,8 @@ 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 { buildTrailBlockId, buildUndeliverableFinalNotice, captureTurnArtifactSnapshot, collectTurnArtifacts, IDLE_TIMEOUT_MS, PLAN_BLOCK_TITLE, collectMissedInboundMessages, STARTUP_RECOVERY_MAX_MESSAGES, STARTUP_RECOVERY_PAGE_SIZE, } from '@canonmsg/coding-agent-host';
-import { RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildRuntimeCardOutcome, resolveQuestionAllowOther, buildCanonTurnContextV2, buildConfiguredWorkspaceOptionsWithRoots, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, buildCanonInboundFrameV1, 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, decideAutoReply, initRTDBAuth, buildLocalRuntimeId, heartbeatLocalRuntimeEntry, markLocalRuntimeStopped, normalizeTurnMetadata, parseRuntimeCardV1, parseTurnVerbosityConfig, RuntimeRequestManager, prepareConversationEnvironment, loadHostSessionConfig, releaseConversationEnvironment, resolveCanonAgent, verifyResolvedAgentEnvironment, CanonApiError, loadRuntimeSessionState, sendMessageWithRetry, sendMessageWithRetryChunked, saveRuntimeSessionState, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, renderCodingHostInboundPrompt, resolveHostWorkspaceCwd, resolveSilentTurnDelivery, resolveTurnVerbosity, shouldTriggerAgentTurn, upsertLocalRuntimeEntry, } from '@canonmsg/core';
+import { buildTrailBlockId, buildUndeliverableFinalNotice, captureTurnArtifactSnapshot, createTurnArtifactRouter, IDLE_TIMEOUT_MS, PLAN_BLOCK_TITLE, resolveTurnArtifactRouting, collectMissedInboundMessages, STARTUP_RECOVERY_MAX_MESSAGES, STARTUP_RECOVERY_PAGE_SIZE, } from '@canonmsg/coding-agent-host';
+import { RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildRuntimeCardOutcome, resolveQuestionAllowOther, buildCanonTurnContextV2, buildConfiguredWorkspaceOptionsWithRoots, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, buildCanonInboundFrameV1, 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, decideAutoReply, initRTDBAuth, buildLocalRuntimeId, heartbeatLocalRuntimeEntry, markLocalRuntimeStopped, normalizeTurnMetadata, parseRuntimeCardV1, parseTurnVerbosityConfig, RuntimeRequestManager, prepareConversationEnvironment, loadHostSessionConfig, releaseConversationEnvironment, resolveCanonAgent, verifyResolvedAgentEnvironment, CanonApiError, loadRuntimeSessionState, sendMessageWithRetry, sendMessageWithRetryChunked, saveRuntimeSessionState, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, renderCodingHostInboundPrompt, resolveHostWorkspaceCwd, isSilentTurnSuppressed, resolveSilentTurnDelivery, resolveTurnVerbosity, shouldTriggerAgentTurn, upsertLocalRuntimeEntry, } from '@canonmsg/core';
 import { CodexConversationAdapter, } from './adapter.js';
 import { CodexAppServerAdapter, } from './app-server-adapter.js';
 import { CODEX_APP_DYNAMIC_TOOLS, CODEX_NO_REPLY_MODEL_TOOL_NAME, classifyCodexAppToolRequest, codexNoReplyToolResult, deniedCodexAppToolResult, handleCodexAppToolCall, isCodexAppToolCall, readCodexNoReplyReason, } from './codex-app-tools.js';
@@ -538,6 +538,35 @@ export function planCodexStreamingWrite(input) {
 export function shouldStopTypingDotsOnStreamedText(turnVerbosity) {
     return turnVerbosity !== 'quiet';
 }
+/**
+ * Whether this turn may post the media it generated in the workspace.
+ *
+ * Where the shared ruling (`resolveTurnArtifactRouting`) meets this host's
+ * per-turn state, and the only place silence is resolved for Codex artifacts:
+ * `silenced` here is the RAW `no_reply` sentinel, and it is weighed against the
+ * turn's own final text by `isSilentTurnSuppressed` — the same switch the final
+ * delivery reads. Flipping `DEFAULT_SILENT_TURN_PRECEDENCE` to `advisory`
+ * therefore moves a turn's text and its files together; it cannot leave Codex
+ * talking about a chart it then withholds.
+ *
+ * `finalText` is the model's own reply, never Canon's failure notice: the
+ * notice is a host diagnostic and goes out whether the turn spoke or not.
+ *
+ * Interruption is not a parameter. Codex's `result.interrupted` branch is the
+ * one completion branch that never calls the funnel, so the axis is dead on
+ * the normal paths. The known gap is the catch branch, which routes
+ * unconditionally and IS reachable after an interrupt (a hard interrupt can
+ * make `runTurn` reject rather than resolve); an interrupted turn's artifacts
+ * can still be posted alongside the failure notice there, as they always
+ * could. Claude gates that case; matching it needs an interrupt signal Codex
+ * does not currently carry into the catch without a race.
+ */
+export function shouldRouteCodexTurnArtifacts(input) {
+    return resolveTurnArtifactRouting({
+        artifactRoutingMode: input.artifactRoutingMode,
+        silenced: isSilentTurnSuppressed({ silenced: input.silenced, finalText: input.finalText }),
+    });
+}
 export async function main() {
     setDefaultResultOrder('ipv4first');
     const { values: args } = parseArgs({
@@ -1683,34 +1712,6 @@ export async function main() {
             },
         });
     }
-    async function routeWorkspaceGeneratedArtifacts(session, baseline) {
-        if (!baseline)
-            return;
-        const logPrefix = `[canon-codex] [${session.conversationId.slice(0, 8)}]`;
-        try {
-            const result = await collectTurnArtifacts({
-                cwd: session.cwd,
-                baseline,
-            });
-            for (const file of result.files) {
-                try {
-                    const { messageId } = await sendTurnArtifactFile(session, file);
-                    console.error(`${logPrefix} Routed generated artifact ${file.relativePath ?? file.fileName} (${messageId})`);
-                }
-                catch (error) {
-                    console.error(`${logPrefix} Artifact upload failed for ${file.relativePath ?? file.fileName}: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-            for (const skipped of result.skipped) {
-                if (skipped.reason === 'too-large' || skipped.reason === 'file-cap' || skipped.reason === 'scan-limit') {
-                    console.error(`${logPrefix} Artifact skipped ${skipped.fileName} (${skipped.reason})`);
-                }
-            }
-        }
-        catch (error) {
-            console.error(`${logPrefix} Artifact routing failed:`, error instanceof Error ? error.message : error);
-        }
-    }
     async function runNextTurn(session) {
         if (session.running || session.closed)
             return;
@@ -1757,15 +1758,27 @@ export async function main() {
             writeCodexStreaming(session, '', 'thinking');
         }
         let artifactBaseline = null;
-        let artifactsRouted = false;
-        const routeArtifactsOnce = async () => {
-            if (artifactsRouted)
-                return;
-            artifactsRouted = true;
-            if (nextTurn.artifactRoutingMode === 'workspace-generated') {
-                await routeWorkspaceGeneratedArtifacts(session, artifactBaseline);
-            }
-        };
+        // The model's own reply for this turn, once it is known. Read by the gate
+        // below so silence is weighed against the SAME text the final delivery
+        // weighs it against; null while the turn runs and after a throw, which is
+        // the honest answer — no reply was produced.
+        let turnFinalText = null;
+        // Every completion branch below funnels through this router, and it owns
+        // the collect-and-post loop, so there is no un-gated path left to the
+        // workspace: the failure branches still send Canon's notice, and none of
+        // them can post the artifacts of a turn that chose silence.
+        const artifactRouter = createTurnArtifactRouter({
+            decide: () => shouldRouteCodexTurnArtifacts({
+                artifactRoutingMode: nextTurn.artifactRoutingMode,
+                silenced: session.currentTurnSilenced,
+                finalText: turnFinalText,
+            }),
+            baseline: () => artifactBaseline,
+            cwd: () => session.cwd,
+            send: (file) => sendTurnArtifactFile(session, file),
+            log: (line) => console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] ${line}`),
+        });
+        const routeArtifactsOnce = artifactRouter.route;
         try {
             const turnId = session.currentTurnId ?? randomUUID();
             session.currentTurnId = turnId;
@@ -1928,6 +1941,10 @@ export async function main() {
                 session.currentTurnSilenced = false;
                 result = await runTurnOnce();
             }
+            // Both the artifact gate and the final delivery weigh silence against
+            // this text, and they must weigh the same one — set it before any
+            // completion branch runs, including the ones that route first.
+            turnFinalText = result.finalMessage ?? null;
             if (session.adapter instanceof CodexAppServerAdapter) {
                 const resolvedModel = session.adapter.getResolvedModel();
                 const resolvedEffort = session.adapter.getResolvedReasoningEffort();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.24.0",
+  "version": "0.25.0",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/index.js",
@@ -30,8 +30,8 @@
   },
   "dependencies": {
     "@canonmsg/agent-sdk": "^8.2.0",
-    "@canonmsg/coding-agent-host": "^0.4.0",
-    "@canonmsg/core": "^10.0.0"
+    "@canonmsg/coding-agent-host": "^0.5.0",
+    "@canonmsg/core": "^10.1.0"
   },
   "engines": {
     "node": ">=18.0.0"