@canonmsg/codex-plugin 0.24.0 → 0.25.1

package/dist/codex-app-tools.d.ts

@@ -1,3 +1,4 @@
+import { type NoReplyReportClient } from '@canonmsg/core';
 type JsonRecord = Record<string, unknown>;
 interface DynamicToolSpec {
     [key: string]: unknown;
@@ -60,6 +61,22 @@ export declare function readCodexNoReplyReason(params: CodexAppToolCallParams):
  * `no_reply` ack sends so the two can never drift.
  */
 export declare function codexNoReplyToolResult(): DynamicToolCallResponse;
+/**
+ * Answer a `no_reply` dynamic-tool call end to end: mark the turn silent
+ * FIRST, then report the outcome to the server (fire-and-forget telemetry,
+ * `reportNoReplyOutcome` swallows every failure), then ack the model. The
+ * report can never change the turn: a rejecting or unreachable server leaves
+ * the flag and the ack exactly as they were. `sourceMessageId` is the
+ * binding's own record of the message that started this turn — never
+ * model-supplied.
+ */
+export declare function answerCodexNoReply(input: {
+    client: NoReplyReportClient;
+    conversationId: string;
+    sourceMessageId: string | null;
+    params: CodexAppToolCallParams;
+    markSilenced: () => void;
+}): DynamicToolCallResponse;
 /** How the host should answer one `codex_app` dynamic-tool call. */
 export type CodexAppToolDisposition = 'no-reply' | 'denied-transport' | 'denied-non-owner' | 'bridge';
 /**

package/dist/codex-app-tools.js

@@ -1,4 +1,4 @@
-import { NO_REPLY_ACK_NOTE } from '@canonmsg/core';
+import { NO_REPLY_ACK_NOTE, reportNoReplyOutcome } from '@canonmsg/core';
 const emptyObjectSchema = {
     type: 'object',
     properties: {},
@@ -262,6 +262,24 @@ export function readCodexNoReplyReason(params) {
 export function codexNoReplyToolResult() {
     return toolResult(true, { status: 'acknowledged', note: NO_REPLY_ACK_NOTE });
 }
+/**
+ * Answer a `no_reply` dynamic-tool call end to end: mark the turn silent
+ * FIRST, then report the outcome to the server (fire-and-forget telemetry,
+ * `reportNoReplyOutcome` swallows every failure), then ack the model. The
+ * report can never change the turn: a rejecting or unreachable server leaves
+ * the flag and the ack exactly as they were. `sourceMessageId` is the
+ * binding's own record of the message that started this turn — never
+ * model-supplied.
+ */
+export function answerCodexNoReply(input) {
+    input.markSilenced();
+    reportNoReplyOutcome(input.client, {
+        conversationId: input.conversationId,
+        ...(input.sourceMessageId ? { messageId: input.sourceMessageId } : {}),
+        reason: readCodexNoReplyReason(input.params),
+    });
+    return codexNoReplyToolResult();
+}
 /**
  * The whole `codex_app` admission decision, as data.
  *

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,11 +5,11 @@ 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';
+import { CODEX_APP_DYNAMIC_TOOLS, CODEX_NO_REPLY_MODEL_TOOL_NAME, answerCodexNoReply, classifyCodexAppToolRequest, deniedCodexAppToolResult, handleCodexAppToolCall, isCodexAppToolCall, readCodexNoReplyReason, } from './codex-app-tools.js';
 import { mapCanonApprovalResultToCodexDecision, mapCodexAppServerApprovalRequest, } from './app-server-approval.js';
 import { clearStoredThreadId, buildCodexThreadPolicyFingerprint, loadStoredThreadId, saveStoredThreadId, } from './session-store.js';
 import { deriveCodexPermissionEnvelope, mapCanonPermissionToCodex, } from './permission-mode.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({
@@ -1337,7 +1366,7 @@ export async function main() {
         const args = isRecord(params.arguments) ? params.arguments : null;
         return params.card ?? params.cardDocument ?? input?.card ?? args?.card ?? null;
     }
-    async function handleCodexServerRequest(session, request, requestingUserId) {
+    async function handleCodexServerRequest(session, request, requestingUserId, sourceMessageId) {
         const requestId = String(request.id);
         const params = request.params;
         const expiresAt = Date.now() + 30 * 60_000;
@@ -1350,10 +1379,16 @@ export async function main() {
                 canUseAppTools: session.currentTurnCanUseCodexAppTools,
             });
             if (disposition === 'no-reply') {
-                session.currentTurnSilenced = true;
+                const result = answerCodexNoReply({
+                    client,
+                    conversationId: session.conversationId,
+                    sourceMessageId,
+                    params,
+                    markSilenced: () => { session.currentTurnSilenced = true; },
+                });
                 console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn chose no_reply`
                     + ` (reason: ${readCodexNoReplyReason(params) ? 'given' : 'none'})`);
-                return codexNoReplyToolResult();
+                return result;
             }
             if (disposition === 'denied-non-owner') {
                 return deniedCodexAppToolResult('Only the Canon owner can use codex_app tools.');
@@ -1683,34 +1718,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 +1764,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;
@@ -1911,7 +1930,7 @@ export async function main() {
             };
             const runTurnOnce = () => session.adapter.runTurn(turnPrompt, handleCodexEvent, logCodexLine, turnImagePaths, turnMediaAddDirs, {
                 planMode: nextTurn.planMode,
-                onServerRequest: (request) => handleCodexServerRequest(session, request, nextTurn.requestingUserId ?? null),
+                onServerRequest: (request) => handleCodexServerRequest(session, request, nextTurn.requestingUserId ?? null, nextTurn.sourceMessageId ?? null),
             });
             let result = await runTurnOnce();
             if (!result.interrupted
@@ -1928,6 +1947,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.1",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/index.js",
@@ -29,9 +29,9 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@canonmsg/agent-sdk": "^8.2.0",
-    "@canonmsg/coding-agent-host": "^0.4.0",
-    "@canonmsg/core": "^10.0.0"
+    "@canonmsg/agent-sdk": "^8.3.0",
+    "@canonmsg/coding-agent-host": "^0.5.0",
+    "@canonmsg/core": "^10.2.0"
   },
   "engines": {
     "node": ">=18.0.0"