@canonmsg/codex-plugin 0.23.7 → 0.25.0

package/README.md

@@ -55,6 +55,10 @@ You do not need a git repo for host mode. Any readable working directory is vali
 - Interrupt by terminating the active Codex turn
 - Tool/running status surfaced while Codex is working
 - Reasoning-effort selection, resolved against what the active model accepts
+- Deliberate silence: the model can end a turn without posting anything, by
+  calling the `codex_app.no_reply` tool (app-server transport only)
+- Quiet group turns: in groups the host shows the thinking indicator and the
+  answer only; direct chats keep the live preview and margin activity
 
 ## Transports
 
@@ -70,7 +74,9 @@ deltas, and model/effort discovery from the runtime.
 state, tool activity, and completed assistant-message previews, but not
 token-by-token deltas, and it cannot block on approvals — Canon labels the
 session with that warning rather than implying a gate it does not have. Without
-discovery it also offers no model picker and a fixed effort list.
+discovery it also offers no model picker and a fixed effort list. It registers
+no dynamic tools either, so `no_reply` is unavailable there, the same way rich
+cards are.
 
 Set `CANON_CODEX_TRANSPORT=exec` or `CANON_CODEX_TRANSPORT=app-server` to skip
 the probe when it misfires.
@@ -127,6 +133,36 @@ switch to `--full-auto`.
 
 Do not start Canon with `--sandbox danger-full-access` as an unlabeled default. Use `--dangerously-bypass-approvals-and-sandbox` only when you intentionally want Canon to advertise the owner-only Bypass policy.
 
+### Turn verbosity
+
+```bash
+canon-codex --cwd /path/to/project --turn-verbosity quiet
+```
+
+`--turn-verbosity <verbose|quiet|auto>` controls how much of a turn's middle
+readers see. `CANON_TURN_VERBOSITY` is the environment fallback; the flag wins
+when both are set.
+
+| Value | Effect |
+|---|---|
+| `auto` (default, same as unset) | Verbose in direct chats, quiet in groups |
+| `verbose` | Live streaming text plus the margin activity rows on the final, everywhere |
+| `quiet` | The thinking indicator and the answer, nothing in between, everywhere |
+
+Quiet drops the live `/streaming` narration — including the plan text this host
+would otherwise publish as the agent's speech — and the final's `turnTrail`
+activity rows. It does **not** drop the thinking indicator (which now stays up
+for the turn's whole working phase rather than handing over to a bubble that
+never appears — while the turn is parked on an approval the clients suppress an
+agent's dots and the header line carries the state, and the dots come back when
+the human answers), the turn state, the answer including every part of a long chunked one, failure
+notices, workspace artifacts, or approval and question cards and their receipts.
+
+This host parses flags strictly, so an unknown flag stops it at startup; an
+unrecognized `--turn-verbosity` VALUE is reported once and then ignored in
+favour of the default, because taking a local agent offline over a presentation
+setting would be the worse failure.
+
 Local smoke test:
 
 ```bash

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

@@ -35,8 +35,48 @@ type DynamicToolCallResponse = {
         text: string;
     }>;
 };
+/**
+ * Deliberate silence (`canon.verbs.v1` `no_reply`). The model sees it as
+ * `codex_app.no_reply` — the dynamic-tool namespace is fixed by the transport —
+ * and the Canon host answers it directly, because the flag it sets belongs to
+ * the host's turn, not to the app-server bridge.
+ */
+export declare const CODEX_NO_REPLY_TOOL_NAME = "no_reply";
+/**
+ * What the model actually sees for the tool above, for prompt text that names
+ * it (the group posture cue). Only meaningful on the app-server transport —
+ * the `exec --json` transport registers no dynamic tools.
+ */
+export declare const CODEX_NO_REPLY_MODEL_TOOL_NAME = "codex_app.no_reply";
 export declare const CODEX_APP_DYNAMIC_TOOLS: ReadonlyArray<DynamicToolSpec>;
 export declare function isCodexAppToolCall(params: Record<string, unknown>): boolean;
 export declare function deniedCodexAppToolResult(reason: string): DynamicToolCallResponse;
+/** True when this dynamic-tool call is the deliberate-silence verb. */
+export declare function isCodexNoReplyToolCall(params: CodexAppToolCallParams): boolean;
+/** Private rationale, when the model supplied one. Logged, never rendered. */
+export declare function readCodexNoReplyReason(params: CodexAppToolCallParams): string | undefined;
+/**
+ * The model-facing closure sentence, read from the same definition the server's
+ * `no_reply` ack sends so the two can never drift.
+ */
+export declare function codexNoReplyToolResult(): DynamicToolCallResponse;
+/** How the host should answer one `codex_app` dynamic-tool call. */
+export type CodexAppToolDisposition = 'no-reply' | 'denied-transport' | 'denied-non-owner' | 'bridge';
+/**
+ * The whole `codex_app` admission decision, as data.
+ *
+ * `no-reply` is deliberately ranked ABOVE the owner gate: a group turn is
+ * usually a non-owner turn, and those are exactly the turns silence exists for,
+ * so gating it would mean the feature can never fire where it is needed.
+ * Staying quiet also grants nothing — it is the absence of an action. That
+ * ordering is the one line the whole Codex binding rests on, which is why it
+ * lives here, in a pure function a test can pin, instead of only in the host
+ * closure.
+ */
+export declare function classifyCodexAppToolRequest(input: {
+    params: CodexAppToolCallParams;
+    transportSupportsAppTools: boolean;
+    canUseAppTools: boolean;
+}): CodexAppToolDisposition;
 export declare function handleCodexAppToolCall(runtime: CodexAppToolRuntime, params: CodexAppToolCallParams): Promise<DynamicToolCallResponse>;
 export {};

package/dist/codex-app-tools.js

@@ -1,3 +1,4 @@
+import { NO_REPLY_ACK_NOTE } from '@canonmsg/core';
 const emptyObjectSchema = {
     type: 'object',
     properties: {},
@@ -81,6 +82,19 @@ const forkEnvironmentSchema = {
 function tool(name, description, inputSchema, deferLoading = true) {
     return { namespace: 'codex_app', name, description, inputSchema, deferLoading };
 }
+/**
+ * Deliberate silence (`canon.verbs.v1` `no_reply`). The model sees it as
+ * `codex_app.no_reply` — the dynamic-tool namespace is fixed by the transport —
+ * and the Canon host answers it directly, because the flag it sets belongs to
+ * the host's turn, not to the app-server bridge.
+ */
+export const CODEX_NO_REPLY_TOOL_NAME = 'no_reply';
+/**
+ * What the model actually sees for the tool above, for prompt text that names
+ * it (the group posture cue). Only meaningful on the app-server transport —
+ * the `exec --json` transport registers no dynamic tools.
+ */
+export const CODEX_NO_REPLY_MODEL_TOOL_NAME = `codex_app.${CODEX_NO_REPLY_TOOL_NAME}`;
 export const CODEX_APP_DYNAMIC_TOOLS = [
     tool('automation_update', 'Create, update, view, or delete Codex app automations. Canon exposes the name for compatibility, but does not manage Desktop automations.', {
         type: 'object',
@@ -191,6 +205,23 @@ export const CODEX_APP_DYNAMIC_TOOLS = [
         },
         required: ['threadId', 'title'],
     }),
+    // Canon's `no_reply` verb, projected into the only model-visible tool surface
+    // the Codex transport gives us. It is answered by the Canon host itself (see
+    // `handleCodexServerRequest`), never by `handleCodexAppToolCall` — the host
+    // owns the turn this call is about.
+    tool(CODEX_NO_REPLY_TOOL_NAME, 'End your turn without posting anything to the conversation. Use it in group '
+        + 'chats when you have nothing to add — no message is created, so no other '
+        + 'member or agent is triggered. Optional private reason (logged, never '
+        + 'shown). After calling this, produce no further text.', {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            reason: {
+                type: 'string',
+                description: 'Never rendered; logged only.',
+            },
+        },
+    }, false),
 ];
 const CODEX_APP_TOOL_NAMES = new Set(CODEX_APP_DYNAMIC_TOOLS.map((entry) => String(entry.name)));
 const UNSUPPORTED_TOOLS = new Map([
@@ -215,11 +246,56 @@ export function isCodexAppToolCall(params) {
 export function deniedCodexAppToolResult(reason) {
     return toolResult(false, { error: reason });
 }
+/** True when this dynamic-tool call is the deliberate-silence verb. */
+export function isCodexNoReplyToolCall(params) {
+    return normalizeToolName(params.tool) === CODEX_NO_REPLY_TOOL_NAME;
+}
+/** Private rationale, when the model supplied one. Logged, never rendered. */
+export function readCodexNoReplyReason(params) {
+    const args = parseToolArguments(params.arguments);
+    return readString(args, 'reason');
+}
+/**
+ * The model-facing closure sentence, read from the same definition the server's
+ * `no_reply` ack sends so the two can never drift.
+ */
+export function codexNoReplyToolResult() {
+    return toolResult(true, { status: 'acknowledged', note: NO_REPLY_ACK_NOTE });
+}
+/**
+ * The whole `codex_app` admission decision, as data.
+ *
+ * `no-reply` is deliberately ranked ABOVE the owner gate: a group turn is
+ * usually a non-owner turn, and those are exactly the turns silence exists for,
+ * so gating it would mean the feature can never fire where it is needed.
+ * Staying quiet also grants nothing — it is the absence of an action. That
+ * ordering is the one line the whole Codex binding rests on, which is why it
+ * lives here, in a pure function a test can pin, instead of only in the host
+ * closure.
+ */
+export function classifyCodexAppToolRequest(input) {
+    if (!input.transportSupportsAppTools)
+        return 'denied-transport';
+    if (isCodexNoReplyToolCall(input.params))
+        return 'no-reply';
+    if (!input.canUseAppTools)
+        return 'denied-non-owner';
+    return 'bridge';
+}
 export async function handleCodexAppToolCall(runtime, params) {
     const toolName = normalizeToolName(params.tool);
     if (!toolName || !CODEX_APP_TOOL_NAMES.has(toolName)) {
         return toolResult(false, { error: `Unsupported codex_app tool: ${String(params.tool ?? 'unknown')}` });
     }
+    if (toolName === CODEX_NO_REPLY_TOOL_NAME) {
+        // Unreachable through the host, which intercepts `no_reply` before this
+        // bridge (only the host can mark its own turn silent). Answering with a
+        // bare ack here would tell the model it went quiet when nothing did.
+        return toolResult(false, {
+            tool: toolName,
+            error: 'no_reply is answered by the Canon host, not the app-tool bridge.',
+        });
+    }
     const unsupportedReason = UNSUPPORTED_TOOLS.get(toolName);
     if (unsupportedReason) {
         return toolResult(false, { tool: toolName, error: unsupportedReason });

package/dist/host.d.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { type CanonRuntimeCommandDescriptor, type CanonRuntimeDescriptor, type CanonRuntimePresentationPolicy, type ExecutionEnvironmentMode, type WorkspaceOption, type CanonWorkspaceRootMetadata } from '@canonmsg/core';
+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';
 interface HostSessionState {
@@ -67,5 +68,102 @@ export declare function getCodexRequestingUserId(message: {
     senderId: string;
     senderType?: 'human' | 'ai_agent';
 }): string | null;
+/**
+ * `--turn-verbosity` beats `CANON_TURN_VERBOSITY`; `null` means "unset, use the
+ * per-conversation-type default".
+ *
+ * An unparseable value is reported and ignored rather than fatal. This host's
+ * `parseArgs` is `strict: true`, so an unknown FLAG already stops the process —
+ * that is the check worth having. A wrong VALUE is a presentation choice, and
+ * taking a local agent offline over one would be a worse failure than showing
+ * the default. An empty declaration (`ENV=` in a Dockerfile, `--turn-verbosity
+ * ''`) is absence, not a mistake, so it says nothing.
+ */
+export declare function resolveConfiguredCodexTurnVerbosity(input: {
+    flag?: unknown;
+    env?: string | undefined;
+    onWarning?: (message: string) => void;
+}): TurnVerbosityConfig | null;
+/**
+ * The turn state a quiet turn publishes to `/turn-state`.
+ *
+ * Current clients render "is thinking" for every open non-waiting state, so
+ * the chat header is unchanged. It exists for app binaries older than #602,
+ * whose typing-dot filter suppressed an agent on turn state `streaming`/`tool`
+ * because a live bubble was expected to carry the state instead — and a quiet
+ * turn has no bubble. The one current consumer that reads the difference is the
+ * direct-chat session strip, which labels `streaming` "Streaming" / "Live
+ * preview"; a direct chat started with an explicit quiet therefore reads
+ * "Thinking" for the whole turn, which is what it is. `waiting_input` is left
+ * alone: it changes what the header says and how the clients treat the dots,
+ * and a turn blocked on a human is not thinking.
+ */
+export declare function publishedCodexTurnState(state: TurnLifecycleState, turnVerbosity: TurnVerbosity): TurnLifecycleState;
+/**
+ * The `/streaming` write for one live-node update, or `null` for none.
+ *
+ * Extracted from `writeCodexStreaming` so the quiet gate covering all eight
+ * call sites — the turn-open seed, assistant text, the plan update (which
+ * passes its text as the node's SPEECH, the loudest step emission this host
+ * has), waiting, command start/completion, and the two card transitions — is a
+ * unit a test can hold, rather than one inline comparison a refactor can drop
+ * in silence.
+ *
+ * `liveText` is returned in BOTH modes and is deliberately outside the gate:
+ * every downstream reader, including the final trail and the turn-exit error,
+ * still has to see what the turn produced. A quiet turn publishes no node at
+ * all rather than a status-only one, so `onStreamingCleared` has nothing to
+ * salvage into a durable bubble if the turn dies mid-flight.
+ */
+export declare function planCodexStreamingWrite(input: {
+    turnVerbosity: TurnVerbosity;
+    /** The new live text, or `null` to keep what the turn already had. */
+    text: string | null;
+    liveText: string;
+    status: RuntimeStreamingPayload['status'];
+    turnId: string | null;
+    blocks: TurnOutputBlock[];
+}): {
+    liveText: string;
+    write: RuntimeStreamingPayload | null;
+};
+/**
+ * When streamed text starts arriving, do the typing dots retire?
+ *
+ * In verbose they do, and should: the live bubble becomes the indicator, and
+ * two indicators for one turn is noise. A quiet turn has no bubble, so the
+ * dots are the only thing the reader has for the whole generation phase — the
+ * longest stretch of the turn. Shared with the Claude host, which spells the
+ * 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, RuntimeRequestManager, prepareConversationEnvironment, loadHostSessionConfig, releaseConversationEnvironment, resolveCanonAgent, verifyResolvedAgentEnvironment, CanonApiError, loadRuntimeSessionState, sendMessageWithRetry, sendMessageWithRetryChunked, saveRuntimeSessionState, buildBoundedTurnTrail, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, renderCodingHostInboundPrompt, resolveHostWorkspaceCwd, 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, deniedCodexAppToolResult, handleCodexAppToolCall, isCodexAppToolCall, } from './codex-app-tools.js';
+import { CODEX_APP_DYNAMIC_TOOLS, CODEX_NO_REPLY_MODEL_TOOL_NAME, classifyCodexAppToolRequest, codexNoReplyToolResult, 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';
@@ -18,7 +18,7 @@ import { buildCodexModelGuardMessage, formatCodexTurnFailure, isRecoverableCodex
 import { startCodexStreamInBackground } from './host-lifecycle.js';
 import { createCodexControlPoller } from './control-channel.js';
 import { runCli } from '@canonmsg/core';
-import { applyTextSegmentBlock, beginCommandBlock, claimCommandBlock, createCommandBlockTracker, } from './turn-activity.js';
+import { applyTextSegmentBlock, beginCommandBlock, buildCodexFinalTurnTrail, claimCommandBlock, createCommandBlockTracker, } from './turn-activity.js';
 import { FALLBACK_CODEX_EFFORT_OPTIONS, buildCodexEffortOptions, buildCodexModelOptions, readCodexConfiguredEffort, resolveCodexDefaultModel, resolveCodexEffortForModel, } from './model-catalog.js';
 const HELP = `canon-codex — run a local Codex agent host for Canon
 
@@ -38,6 +38,10 @@ COMMON FLAGS
                                       Detail visibility preset
   --show-runtime-detail <field>        Override a hidden detail field
   --hide-runtime-detail <field>        Hide a runtime detail field
+  --turn-verbosity <verbose|quiet|auto>
+                                      How much of a turn's middle readers see.
+                                      Default (auto): verbose in direct chats,
+                                      quiet in groups. Env: CANON_TURN_VERBOSITY
   --help, -h                           Show this help
   --version, -V                        Show package version
 
@@ -88,6 +92,12 @@ const CODEX_RUNTIME_CAPABILITIES = {
     supportsNonFinalPermanentMessages: false,
 };
 let workingDir = process.cwd();
+/**
+ * Agent-developer setting, resolved once at startup. Deliberately NOT read from
+ * `/session-config`: that path is the USER's per-conversation control plane,
+ * and owner ruling 5 puts turn verbosity outside user control.
+ */
+let configuredTurnVerbosity = null;
 let workspaceOptions = [];
 let workspaceRoots = [];
 let workspaceRootMetadata = [];
@@ -321,7 +331,7 @@ function buildCanonPrompt(input) {
         provenance: input.provenance,
         replyContext: input.replyContext,
         message: input.message,
-    })));
+    })), input.noReplyToolName ? { noReplyToolName: input.noReplyToolName } : {});
 }
 function renderInboundContent(message, materialized) {
     return renderCanonHostInboundContent(message, materialized);
@@ -440,6 +450,123 @@ function readString(record, key) {
     const value = record[key];
     return typeof value === 'string' && value.trim() ? value.trim() : undefined;
 }
+/**
+ * `--turn-verbosity` beats `CANON_TURN_VERBOSITY`; `null` means "unset, use the
+ * per-conversation-type default".
+ *
+ * An unparseable value is reported and ignored rather than fatal. This host's
+ * `parseArgs` is `strict: true`, so an unknown FLAG already stops the process —
+ * that is the check worth having. A wrong VALUE is a presentation choice, and
+ * taking a local agent offline over one would be a worse failure than showing
+ * the default. An empty declaration (`ENV=` in a Dockerfile, `--turn-verbosity
+ * ''`) is absence, not a mistake, so it says nothing.
+ */
+export function resolveConfiguredCodexTurnVerbosity(input) {
+    const sources = [
+        ['--turn-verbosity', typeof input.flag === 'string' ? input.flag : undefined],
+        ['CANON_TURN_VERBOSITY', input.env],
+    ];
+    for (const [name, raw] of sources) {
+        const parsed = parseTurnVerbosityConfig(raw);
+        if (parsed)
+            return parsed;
+        if (raw && raw.trim()) {
+            input.onWarning?.(`Ignoring ${name}=${JSON.stringify(raw)} — expected verbose, quiet or auto.`);
+        }
+    }
+    return null;
+}
+/**
+ * The turn state a quiet turn publishes to `/turn-state`.
+ *
+ * Current clients render "is thinking" for every open non-waiting state, so
+ * the chat header is unchanged. It exists for app binaries older than #602,
+ * whose typing-dot filter suppressed an agent on turn state `streaming`/`tool`
+ * because a live bubble was expected to carry the state instead — and a quiet
+ * turn has no bubble. The one current consumer that reads the difference is the
+ * direct-chat session strip, which labels `streaming` "Streaming" / "Live
+ * preview"; a direct chat started with an explicit quiet therefore reads
+ * "Thinking" for the whole turn, which is what it is. `waiting_input` is left
+ * alone: it changes what the header says and how the clients treat the dots,
+ * and a turn blocked on a human is not thinking.
+ */
+export function publishedCodexTurnState(state, turnVerbosity) {
+    if (turnVerbosity !== 'quiet')
+        return state;
+    return state === 'streaming' || state === 'tool' ? 'thinking' : state;
+}
+/**
+ * The `/streaming` write for one live-node update, or `null` for none.
+ *
+ * Extracted from `writeCodexStreaming` so the quiet gate covering all eight
+ * call sites — the turn-open seed, assistant text, the plan update (which
+ * passes its text as the node's SPEECH, the loudest step emission this host
+ * has), waiting, command start/completion, and the two card transitions — is a
+ * unit a test can hold, rather than one inline comparison a refactor can drop
+ * in silence.
+ *
+ * `liveText` is returned in BOTH modes and is deliberately outside the gate:
+ * every downstream reader, including the final trail and the turn-exit error,
+ * still has to see what the turn produced. A quiet turn publishes no node at
+ * all rather than a status-only one, so `onStreamingCleared` has nothing to
+ * salvage into a durable bubble if the turn dies mid-flight.
+ */
+export function planCodexStreamingWrite(input) {
+    const liveText = input.text !== null ? input.text : input.liveText;
+    if (input.turnVerbosity === 'quiet')
+        return { liveText, write: null };
+    return {
+        liveText,
+        write: {
+            text: liveText,
+            status: input.status,
+            messageId: input.turnId ?? undefined,
+            turnId: input.turnId,
+            blocks: input.blocks,
+        },
+    };
+}
+/**
+ * When streamed text starts arriving, do the typing dots retire?
+ *
+ * In verbose they do, and should: the live bubble becomes the indicator, and
+ * two indicators for one turn is noise. A quiet turn has no bubble, so the
+ * dots are the only thing the reader has for the whole generation phase — the
+ * longest stretch of the turn. Shared with the Claude host, which spells the
+ * same decision at its `text_delta` handler.
+ */
+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({
@@ -457,6 +584,7 @@ export async function main() {
             'runtime-visibility': { type: 'string' },
             'show-runtime-detail': { type: 'string', multiple: true },
             'hide-runtime-detail': { type: 'string', multiple: true },
+            'turn-verbosity': { type: 'string' },
             'full-auto': { type: 'boolean' },
             'dangerously-bypass-approvals-and-sandbox': { type: 'boolean' },
         },
@@ -467,6 +595,11 @@ export async function main() {
         process.exitCode = 1;
         return;
     }
+    configuredTurnVerbosity = resolveConfiguredCodexTurnVerbosity({
+        flag: args['turn-verbosity'],
+        env: process.env.CANON_TURN_VERBOSITY,
+        onWarning: (message) => console.error(`[canon-codex] ${message}`),
+    });
     workingDir = (typeof args.cwd === 'string' ? args.cwd : null) || process.cwd();
     const workspaceDiscovery = buildConfiguredWorkspaceOptionsWithRoots({
         primaryCwd: workingDir,
@@ -748,7 +881,7 @@ export async function main() {
             || session.turnState === 'waiting_input';
         runtimeState.writeTurnState(session.conversationId, {
             turnId: session.currentTurnId,
-            state: session.turnState,
+            state: publishedCodexTurnState(session.turnState, session.turnVerbosity),
             queueDepth: session.queue.length,
             currentSpeakerId: agentId,
             lastAcceptedIntent: session.lastAcceptedIntent,
@@ -824,15 +957,39 @@ export async function main() {
         runtimeState.clearStreaming(conversationId).catch(() => { });
     }
     function writeCodexStreaming(session, text, status) {
-        if (text !== null) {
-            session.turnLiveText = text;
-        }
-        runtimeState.writeStreaming(session.conversationId, {
-            text: session.turnLiveText,
+        const plan = planCodexStreamingWrite({
+            turnVerbosity: session.turnVerbosity,
+            text,
+            liveText: session.turnLiveText,
             status,
-            messageId: session.currentTurnId ?? undefined,
             turnId: session.currentTurnId,
             blocks: session.turnBlocks,
+        });
+        session.turnLiveText = plan.liveText;
+        if (!plan.write)
+            return;
+        runtimeState.writeStreaming(session.conversationId, plan.write).catch(() => { });
+    }
+    /**
+     * Blanks the live node for a turn that chose silence. Awaited, unlike
+     * `writeCodexStreaming`: the delete that follows must not race ahead of this
+     * write, or the trigger salvages the un-blanked value into a durable message.
+     * The empty `blocks` array is load-bearing — `fallbackTextFromBlocks`
+     * rebuilds salvage text out of tool-trail titles when only `text` is cleared.
+     *
+     * Left unconditional under quiet, where there is nothing to scrub: the write
+     * costs one no-op round trip on a rare path, and keeping the deliberate-
+     * silence sequence identical in both modes is worth more than saving it.
+     */
+    async function blankCodexStreaming(session) {
+        session.turnLiveText = '';
+        session.turnBlocks = [];
+        await runtimeState.writeStreaming(session.conversationId, {
+            text: '',
+            status: 'thinking',
+            messageId: session.currentTurnId ?? undefined,
+            turnId: session.currentTurnId,
+            blocks: [],
         }).catch(() => { });
     }
     function upsertCodexTextSegment(session, event) {
@@ -882,10 +1039,11 @@ export async function main() {
         });
     }
     function buildFinalTurnTrail(session) {
-        return buildBoundedTurnTrail(session.turnBlocks.map((block) => ({
-            ...block,
-            turnId: session.currentTurnId ?? block.turnId,
-        })));
+        return buildCodexFinalTurnTrail({
+            blocks: session.turnBlocks,
+            turnId: session.currentTurnId,
+            turnVerbosity: session.turnVerbosity,
+        });
     }
     function buildCodexMessageId(session, kind) {
         return `codex-${kind}-${session.currentTurnId ?? randomUUID()}`;
@@ -908,6 +1066,21 @@ export async function main() {
     function startVisibleWorkSignal(session) {
         refreshVisibleWorkSignal(session);
     }
+    /**
+     * Start the dots whatever the turn state says.
+     *
+     * `refreshVisibleWorkSignal` filters on `thinking`/`tool`, which is right for
+     * a verbose turn — once text starts flowing the live bubble is the indicator,
+     * so the dots are meant to retire. A quiet turn has no bubble, so the dots
+     * have to survive the flip to `streaming`, and the filtered helper would
+     * silently do nothing. Cheap to call repeatedly: the publisher skips the
+     * write when it is already active with the same status.
+     */
+    function ensureVisibleWorkSignal(session) {
+        if (!session.running || session.closed)
+            return;
+        typingSignals.start(session.conversationId, 'thinking').catch(() => { });
+    }
     function stopVisibleWorkSignal(session) {
         if (session.typingKeepaliveTimer) {
             clearInterval(session.typingKeepaliveTimer);
@@ -915,6 +1088,29 @@ export async function main() {
         }
         typingSignals.clear(session.conversationId).catch(() => { });
     }
+    /**
+     * A turn parked on an approval, an input request or a card is working again
+     * the moment the answer arrives.
+     *
+     * Codex announces the park — a `thread/status/changed` carrying
+     * `waitingOnApproval`/`waitingOnUserInput`, which the adapter forwards as
+     * `waiting` — but announces no resume, so the host has to draw that edge
+     * itself. Without it `/turn-state` keeps saying "waiting for your reply"
+     * while the agent generates, and the dots stopped at the park never come
+     * back: the clients suppress an agent's dots on `waiting_input`, and the
+     * events that follow a resume (`message`, `plan.updated`) set the state to
+     * `streaming`, which `refreshVisibleWorkSignal` skips. The Claude host draws
+     * the same edge off its `session_state_changed: running` echo.
+     */
+    function resumeTurnFromWaiting(session) {
+        if (session.turnState !== 'waiting_input')
+            return;
+        session.turnState = 'thinking';
+        markTurnProgress(session);
+        writeTurn(session);
+        startVisibleWorkSignal(session);
+        writeCodexStreaming(session, null, 'thinking');
+    }
     function closeSession(conversationId) {
         const session = sessions.get(conversationId);
         if (!session)
@@ -952,6 +1148,7 @@ export async function main() {
             session.currentTurnOpenedAt = null;
             session.currentTurnUpdatedAt = null;
             session.currentTurnCanUseCodexAppTools = false;
+            session.currentTurnSilenced = false;
             session.lastAcceptedIntent = null;
             session.resetRequested = false;
         }
@@ -1062,6 +1259,10 @@ export async function main() {
                     currentTurnOpenedAt: null,
                     currentTurnUpdatedAt: null,
                     currentTurnCanUseCodexAppTools: false,
+                    // Corrected by the first turn that runs; a session with no turn
+                    // publishes nothing anyway, and quiet is never an accident.
+                    turnVerbosity: 'verbose',
+                    currentTurnSilenced: false,
                     activeSelfContextId: null,
                     lastAcceptedIntent: null,
                     pendingDroppedRecoveryCursor: null,
@@ -1093,7 +1294,7 @@ export async function main() {
             pendingSessionCreations.delete(conversationId);
         }
     }
-    function enqueuePrompt(session, prompt, intent = 'queue', toFront = false, sourceMessageId, markAccepted = false, imagePaths = [], mediaAddDirs = [], planMode = false, artifactRoutingMode = 'disabled', canUseCodexAppTools = false, requestingUserId = null) {
+    function enqueuePrompt(session, prompt, intent = 'queue', toFront = false, sourceMessageId, markAccepted = false, imagePaths = [], mediaAddDirs = [], planMode = false, turn = {}) {
         const nextPrompt = {
             prompt,
             intent,
@@ -1102,9 +1303,10 @@ export async function main() {
             imagePaths,
             mediaAddDirs,
             planMode,
-            artifactRoutingMode,
-            canUseCodexAppTools,
-            requestingUserId,
+            artifactRoutingMode: turn.artifactRoutingMode ?? 'disabled',
+            canUseCodexAppTools: turn.canUseCodexAppTools ?? false,
+            ...(turn.turnVerbosity ? { turnVerbosity: turn.turnVerbosity } : {}),
+            requestingUserId: turn.requestingUserId ?? null,
             recoverySequence: ++inboundRecoverySequence,
         };
         if (toFront) {
@@ -1128,13 +1330,33 @@ export async function main() {
             : result.status === 'reject'
                 ? `The plan was declined — keep planning and wait for guidance before implementing.${feedback ? `\n\nNotes:\n${feedback}` : ''}`
                 : `Please revise the plan.${feedback ? `\n\nRevision feedback:\n${feedback}` : ''}`;
-        enqueuePrompt(session, prompt, 'queue', false, result.receiptId ?? null, false, [], [], result.status !== 'approve', 'disabled', false, responseUserId);
+        // No `turnVerbosity`: this prompt continues the same conversation, so it
+        // keeps whatever the session last resolved rather than reverting to the
+        // default.
+        enqueuePrompt(session, prompt, 'queue', false, result.receiptId ?? null, false, [], [], result.status !== 'approve', { requestingUserId: responseUserId });
     }
     function resolveArtifactRoutingMode(participantContext) {
         return participantContext.conversationType === 'direct' && participantContext.isOwner
             ? 'workspace-generated'
             : 'disabled';
     }
+    /**
+     * Everything about a turn that is decided from the message that started it,
+     * in one place. Resolved at the enqueue site and carried on the queue entry,
+     * so a prompt that waits behind another still runs under the answer it
+     * arrived with.
+     */
+    function resolveCodexTurnModes(participantContext, message) {
+        return {
+            artifactRoutingMode: resolveArtifactRoutingMode(participantContext),
+            canUseCodexAppTools: participantContext.isOwner,
+            turnVerbosity: resolveTurnVerbosity({
+                configured: configuredTurnVerbosity,
+                conversationType: participantContext.conversationType,
+            }),
+            requestingUserId: getCodexRequestingUserId(message),
+        };
+    }
     function runtimeCardRequestPayload(method, params) {
         if (method !== 'item/runtimeCard/request'
             && method !== 'runtimeCard/request') {
@@ -1149,12 +1371,28 @@ export async function main() {
         const params = request.params;
         const expiresAt = Date.now() + 30 * 60_000;
         if (request.method === 'item/tool/call' && isCodexAppToolCall(params)) {
-            if (!(session.adapter instanceof CodexAppServerAdapter)) {
-                return deniedCodexAppToolResult('codex_app tools require the Codex app-server transport.');
+            // The admission order — no_reply above the owner gate — is pinned by
+            // `classifyCodexAppToolRequest`'s tests, not by the shape of this block.
+            const disposition = classifyCodexAppToolRequest({
+                params,
+                transportSupportsAppTools: session.adapter instanceof CodexAppServerAdapter,
+                canUseAppTools: session.currentTurnCanUseCodexAppTools,
+            });
+            if (disposition === 'no-reply') {
+                session.currentTurnSilenced = true;
+                console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn chose no_reply`
+                    + ` (reason: ${readCodexNoReplyReason(params) ? 'given' : 'none'})`);
+                return codexNoReplyToolResult();
             }
-            if (!session.currentTurnCanUseCodexAppTools) {
+            if (disposition === 'denied-non-owner') {
                 return deniedCodexAppToolResult('Only the Canon owner can use codex_app tools.');
             }
+            // `disposition` already ruled on the transport (it is checked first, so a
+            // wrong transport never reaches the branches above). This repeats the
+            // test only to narrow the adapter type for the bridge call.
+            if (!(session.adapter instanceof CodexAppServerAdapter)) {
+                return deniedCodexAppToolResult('codex_app tools require the Codex app-server transport.');
+            }
             return await handleCodexAppToolCall({
                 adapter: session.adapter,
                 currentThreadId: session.adapter.getThreadId(),
@@ -1234,13 +1472,7 @@ export async function main() {
                     },
                 });
                 completeTurnBlock(session, `card:${cardId}`, `Card ${response.status}`);
-                if (session.turnState === 'waiting_input') {
-                    session.turnState = 'thinking';
-                    markTurnProgress(session);
-                    writeTurn(session);
-                    startVisibleWorkSignal(session);
-                    writeCodexStreaming(session, null, 'thinking');
-                }
+                resumeTurnFromWaiting(session);
                 return response;
             }
             catch (error) {
@@ -1298,6 +1530,7 @@ export async function main() {
                 },
                 turnId: session.currentTurnId ?? undefined,
             }, { requestId: inputId, expiresAt });
+            resumeTurnFromWaiting(session);
             return { answers: response.status === 'submitted' ? response.answers ?? {} : {} };
         }
         const mappedApproval = mapCodexAppServerApprovalRequest({
@@ -1316,6 +1549,7 @@ export async function main() {
                     : {}),
                 allowSessionRule: responseRouting.allowSessionRule,
             }, { requestId: approvalId, expiresAt });
+            resumeTurnFromWaiting(session);
             if (request.method === 'item/permissions/requestApproval') {
                 return response.decision === 'allow'
                     ? { permissions: isRecord(params.permissions) ? params.permissions : {}, scope: response.sessionRule ? 'session' : 'turn' }
@@ -1354,7 +1588,10 @@ export async function main() {
                 : decision === 'reject'
                     ? `The plan was declined — keep planning and wait for guidance before implementing.${feedback ? `\n\nNotes:\n${feedback}` : ''}`
                     : `Please revise the plan.${feedback ? `\n\nRevision feedback:\n${feedback}` : ''}`;
-            enqueuePrompt(session, prompt, 'queue', false, input.message.id, false, [], [], decision !== 'approve', 'disabled', input.isOwner, getCodexRequestingUserId(input.message));
+            enqueuePrompt(session, prompt, 'queue', false, input.message.id, false, [], [], decision !== 'approve', {
+                canUseCodexAppTools: input.isOwner,
+                requestingUserId: getCodexRequestingUserId(input.message),
+            });
             return;
         }
         let materialized = [];
@@ -1450,18 +1687,17 @@ export async function main() {
             provenance: hydrated.provenance,
             replyContext,
             message: input.message,
+            ...(useAppServer ? { noReplyToolName: CODEX_NO_REPLY_MODEL_TOOL_NAME } : {}),
         });
         if (session.running && deliveryIntent === 'interrupt') {
-            const artifactRoutingMode = resolveArtifactRoutingMode(participantContext);
-            enqueuePrompt(session, prompt, deliveryIntent, true, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode, artifactRoutingMode, participantContext.isOwner, getCodexRequestingUserId(input.message));
+            enqueuePrompt(session, prompt, deliveryIntent, true, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode, resolveCodexTurnModes(participantContext, input.message));
             console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Interrupting current turn for explicit human send-now`);
             await session.adapter.interrupt().catch(() => { });
             clearStreaming(input.conversationId);
             typingSignals.clear(input.conversationId).catch(() => { });
             return;
         }
-        const artifactRoutingMode = resolveArtifactRoutingMode(participantContext);
-        enqueuePrompt(session, prompt, deliveryIntent, false, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode, artifactRoutingMode, participantContext.isOwner, getCodexRequestingUserId(input.message));
+        enqueuePrompt(session, prompt, deliveryIntent, false, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode, resolveCodexTurnModes(participantContext, input.message));
     }
     function sendTurnArtifactFile(session, file) {
         return sendMediaFileMessage(client, session.conversationId, file.path, '', {
@@ -1476,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;
@@ -1520,6 +1728,10 @@ export async function main() {
         session.currentTurnOpenedAt = Date.now();
         session.currentTurnUpdatedAt = session.currentTurnOpenedAt;
         session.currentTurnCanUseCodexAppTools = nextTurn.canUseCodexAppTools === true;
+        // A continuation prompt (a plan-review result) carries none, and keeps the
+        // conversation's last answer rather than silently reverting to verbose.
+        session.turnVerbosity = nextTurn.turnVerbosity ?? session.turnVerbosity;
+        session.currentTurnSilenced = false;
         session.lastAcceptedIntent = nextTurn.intent;
         session.turnState = 'thinking';
         session.lastActivity = Date.now();
@@ -1527,19 +1739,46 @@ export async function main() {
         writeState(session);
         writeTurn(session);
         startVisibleWorkSignal(session);
-        // 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');
+        if (session.turnVerbosity === 'quiet') {
+            // A quiet turn publishes nothing, so it cannot rely on the seed below to
+            // overwrite a node an earlier verbose turn left behind — and a surviving
+            // node carrying the PREVIOUS turn's id makes the clients drop this turn's
+            // live row entirely. Delete instead. What `onStreamingCleared` does with
+            // that delete is the same in both modes and is the ordering we want: a
+            // node that is already gone has nothing to fire on, one left by a turn
+            // that delivered its final is skipped as `turn_complete_exists`, and one
+            // left by a turn that CRASHED mid-narration is salvaged into a durable
+            // message — here, at turn open, before this turn's answer, rather than
+            // arriving after it.
+            clearStreaming(session.conversationId);
+        }
+        else {
+            // 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 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;
@@ -1581,7 +1820,16 @@ export async function main() {
                     session.turnState = 'streaming';
                     markTurnProgress(session);
                     writeTurn(session);
-                    stopVisibleWorkSignal(session);
+                    // The dots stop here only because the live bubble takes over as the
+                    // indicator. A quiet turn has no bubble, so they have to keep
+                    // running — and `ensure`, not merely "don't stop": a turn resuming
+                    // from an approval had them cleared at the park.
+                    if (shouldStopTypingDotsOnStreamedText(session.turnVerbosity)) {
+                        stopVisibleWorkSignal(session);
+                    }
+                    else {
+                        ensureVisibleWorkSignal(session);
+                    }
                     upsertCodexTextSegment(session, event);
                     writeCodexStreaming(session, null, 'streaming');
                     return;
@@ -1590,7 +1838,12 @@ export async function main() {
                     session.turnState = 'streaming';
                     markTurnProgress(session);
                     writeTurn(session);
-                    stopVisibleWorkSignal(session);
+                    if (shouldStopTypingDotsOnStreamedText(session.turnVerbosity)) {
+                        stopVisibleWorkSignal(session);
+                    }
+                    else {
+                        ensureVisibleWorkSignal(session);
+                    }
                     upsertTurnBlock(session, {
                         // Spelled through the shared helper, and with the same fallback
                         // the other host uses: a plan arriving before a turn id would
@@ -1681,8 +1934,17 @@ export async function main() {
                 && isRecoverableCodexThreadError(result.errorText)) {
                 console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Stored thread was not found; clearing and retrying once`);
                 clearStoredThread();
+                // The retry is a whole fresh model turn, so it starts from a fresh
+                // flag — exactly like turn start does. Without this, a `no_reply` from
+                // the attempt that broke would silence a reply the retry did intend
+                // to send, with no diagnostic anywhere.
+                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();
@@ -1697,7 +1959,17 @@ export async function main() {
             if (result.threadId && !session.resetRequested) {
                 saveStoredThreadId(runtimeId, session.conversationId, session.environment.baseCwd, result.threadId, session.environment.mode, session.policyFingerprint);
             }
-            if (!result.interrupted && result.finalMessage && nextTurn.planMode) {
+            if (!result.interrupted
+                && result.finalMessage
+                && nextTurn.planMode
+                // A plan card carries the model's final text into the conversation as a
+                // visible, actionable artifact — it IS posting. Silence is strict here
+                // too: a silenced plan turn falls through to the silent teardown below
+                // and raises no card.
+                && resolveSilentTurnDelivery({
+                    silenced: session.currentTurnSilenced,
+                    finalText: result.finalMessage,
+                }) === 'deliver') {
                 await routeArtifactsOnce();
                 const responseRouting = buildCodexTurnResponseRouting({
                     requestingUserId: nextTurn.requestingUserId,
@@ -1743,7 +2015,15 @@ export async function main() {
                 await handoffFinalMessage(session.conversationId);
                 console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Sent plan approval card`);
             }
-            else if (!result.interrupted && result.finalMessage) {
+            else if (!result.interrupted
+                && result.finalMessage
+                // A turn that called `no_reply` posts nothing. The failure branches
+                // below are deliberately outside this gate: silence suppresses the
+                // MODEL's reply, never Canon's own "this turn broke" diagnostic.
+                && resolveSilentTurnDelivery({
+                    silenced: session.currentTurnSilenced,
+                    finalText: result.finalMessage,
+                }) === 'deliver') {
                 if (isRecoverableCodexThreadError(result.errorText)) {
                     clearStoredThread();
                 }
@@ -1791,6 +2071,22 @@ export async function main() {
             }
             else if (!result.interrupted) {
                 await routeArtifactsOnce();
+                if (session.currentTurnSilenced) {
+                    // Same thread hygiene the delivering branch does: a silent turn that
+                    // also hit a recoverable thread error must not leave the dead thread
+                    // id behind for the next turn to resume.
+                    if (isRecoverableCodexThreadError(result.errorText)) {
+                        clearStoredThread();
+                    }
+                    // Deliberate silence: blank the node (text '' AND an explicit empty
+                    // blocks array) before deleting it, or onStreamingCleared salvages
+                    // this turn's narration into a durable bubble. The live row and the
+                    // typing dots go together — leaving dots behind the removed row for
+                    // the handoff window reads as "started to answer, then gave up".
+                    await blankCodexStreaming(session);
+                    clearStreaming(session.conversationId);
+                    stopVisibleWorkSignal(session);
+                }
                 await handoffFinalMessage(session.conversationId);
             }
             else if (result.interrupted) {
@@ -1846,6 +2142,7 @@ export async function main() {
             session.currentTurnOpenedAt = null;
             session.currentTurnUpdatedAt = null;
             session.currentTurnCanUseCodexAppTools = false;
+            session.currentTurnSilenced = false;
             session.lastAcceptedIntent = null;
             session.resetRequested = false;
             session.lastActivity = Date.now();

package/dist/turn-activity.d.ts

@@ -1,4 +1,4 @@
-import type { TurnOutputBlock } from '@canonmsg/core';
+import type { TurnOutputBlock, TurnVerbosity } from '@canonmsg/core';
 interface RunningCommandBlock {
     command: string;
     blockId: string;
@@ -29,4 +29,18 @@ export declare function claimCommandBlock(tracker: CommandBlockTracker, input: {
     command: string;
     itemId?: string;
 }): string;
+/**
+ * The margin trail to hang on this turn's final.
+ *
+ * The quiet gate lives here, separate from the live-node guard in the host,
+ * because the two are genuinely separate decisions: blocks accumulate whatever
+ * the live writer does, so a turn the reader watched in silence would still
+ * ship a full "Activity — N steps" row on its final if this were forgotten.
+ * One place, both consumers — the answer and the turn-exit error.
+ */
+export declare function buildCodexFinalTurnTrail(input: {
+    blocks: ReadonlyArray<TurnOutputBlock>;
+    turnId: string | null;
+    turnVerbosity: TurnVerbosity;
+}): TurnOutputBlock[];
 export {};

package/dist/turn-activity.js

@@ -1,4 +1,5 @@
 import { buildTrailBlockId, normalizeTrailKey } from '@canonmsg/coding-agent-host';
+import { buildBoundedTurnTrail, shouldPublishTurnTrail } from '@canonmsg/core';
 export function createCommandBlockTracker() {
     return {
         sequence: 0,
@@ -87,3 +88,17 @@ export function claimCommandBlock(tracker, input) {
     }
     return nextCommandBlockId(tracker, input.turnId, itemId);
 }
+/**
+ * The margin trail to hang on this turn's final.
+ *
+ * The quiet gate lives here, separate from the live-node guard in the host,
+ * because the two are genuinely separate decisions: blocks accumulate whatever
+ * the live writer does, so a turn the reader watched in silence would still
+ * ship a full "Activity — N steps" row on its final if this were forgotten.
+ * One place, both consumers — the answer and the turn-exit error.
+ */
+export function buildCodexFinalTurnTrail(input) {
+    if (!shouldPublishTurnTrail(input.turnVerbosity))
+        return [];
+    return buildBoundedTurnTrail(input.blocks.map((block) => ({ ...block, turnId: input.turnId ?? block.turnId })));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.23.7",
+  "version": "0.25.0",
   "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.1.0",
-    "@canonmsg/coding-agent-host": "^0.4.0",
-    "@canonmsg/core": "^9.2.0"
+    "@canonmsg/agent-sdk": "^8.2.0",
+    "@canonmsg/coding-agent-host": "^0.5.0",
+    "@canonmsg/core": "^10.1.0"
   },
   "engines": {
     "node": ">=18.0.0"