@canonmsg/codex-plugin 0.18.4 → 0.18.6

package/dist/adapter.d.ts

@@ -8,6 +8,7 @@ export type CodexEvent = {
 } | {
     type: 'message';
     text: string;
+    itemId?: string;
 } | {
     type: 'plan.updated';
     text: string;

package/dist/adapter.js

@@ -99,7 +99,13 @@ export class CodexConversationAdapter {
                     if (event.item?.type === 'agent_message') {
                         latestMessage = normalizeMessageText(event.item.text);
                         if (latestMessage) {
-                            onEvent({ type: 'message', text: latestMessage });
+                            onEvent({
+                                type: 'message',
+                                text: latestMessage,
+                                ...(typeof event.item.id === 'string' && event.item.id.trim()
+                                    ? { itemId: event.item.id.trim() }
+                                    : {}),
+                            });
                         }
                     }
                     else if (event.item?.type === 'command_execution') {

package/dist/app-server-adapter.js

@@ -338,7 +338,7 @@ export class CodexAppServerAdapter {
             this.messageTextByItem.set(itemId, next);
             this.currentFinalMessage = next.trim() ? next : this.currentFinalMessage;
             if (next.trim())
-                this.currentOnEvent?.({ type: 'message', text: next });
+                this.currentOnEvent?.({ type: 'message', text: next, itemId });
             return;
         }
         if (method === 'turn/plan/updated') {
@@ -372,10 +372,15 @@ export class CodexAppServerAdapter {
         if (method === 'item/completed') {
             const item = params.item;
             if (item?.type === 'agentMessage') {
+                const itemId = readString(item, 'id');
                 const text = readString(item, 'text');
                 if (text) {
                     this.currentFinalMessage = text;
-                    this.currentOnEvent?.({ type: 'message', text });
+                    this.currentOnEvent?.({
+                        type: 'message',
+                        text,
+                        ...(itemId ? { itemId } : {}),
+                    });
                 }
             }
             else if (item?.type === 'commandExecution') {

package/dist/host.d.ts

@@ -1,4 +1,20 @@
 #!/usr/bin/env node
+interface HostSessionState {
+    lastError?: string;
+    model?: string;
+    permissionMode?: string;
+    effort?: string;
+    /** Tokens consumed by the latest completed turn; Codex reports no context window. */
+    contextUsage?: {
+        totalTokens: number;
+    };
+    state: 'idle' | 'running';
+}
+export declare function buildCodexInitialSessionState(input: {
+    model?: string;
+    permissionMode?: string;
+    effort?: string | null;
+}): HostSessionState;
 /** GPT reasoning-effort levels, applied next turn via model_reasoning_effort. */
 export declare const CODEX_EFFORT_OPTIONS: readonly [{
     readonly value: "minimal";
@@ -17,3 +33,4 @@ export declare const CODEX_EFFORT_OPTIONS: readonly [{
     readonly label: "Extra high";
 }];
 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 { buildTurnArtifactContextLine, ensureTurnArtifactDir, flushTurnArtifacts, } from '@canonmsg/coding-agent-host';
-import { RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildRuntimeCardOutcome, buildPlanApprovalRequest, resolveQuestionAllowOther, buildCanonTurnContextV2, buildConfiguredWorkspaceOptionsWithRoots, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, createConversationMetadataLoader, createRuntimeStatePublisher, createTypingStatusPublisher, EXECUTION_ENVIRONMENT_MODES, ExecutionEnvironmentError, CanonClient, CanonStream, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, FINAL_MESSAGE_HANDOFF_MS, getActiveProfileLock, initRTDBAuth, buildLocalRuntimeId, heartbeatLocalRuntimeEntry, loadRuntimeSessionState, markLocalRuntimeStopped, normalizeTurnMetadata, parseRuntimeCardV1, prepareConversationEnvironment, loadHostSessionConfig, releaseConversationEnvironment, resolveCanonAgent, CanonApiError, sendMessageWithRetry, sendMessageWithRetryChunked, shouldTriggerAgentTurn, saveRuntimeSessionState, buildBoundedTurnTrail, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, renderCanonTurnBriefPrompt, resolveHostWorkspaceCwd, upsertLocalRuntimeEntry, } from '@canonmsg/core';
+import { captureTurnArtifactSnapshot, collectTurnArtifacts, } from '@canonmsg/coding-agent-host';
+import { RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildRuntimeCardOutcome, buildPlanApprovalRequest, resolveQuestionAllowOther, buildCanonTurnContextV2, buildConfiguredWorkspaceOptionsWithRoots, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, 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, initRTDBAuth, buildLocalRuntimeId, heartbeatLocalRuntimeEntry, loadRuntimeSessionState, markLocalRuntimeStopped, normalizeTurnMetadata, parseRuntimeCardV1, prepareConversationEnvironment, loadHostSessionConfig, releaseConversationEnvironment, resolveCanonAgent, CanonApiError, sendMessageWithRetry, sendMessageWithRetryChunked, shouldTriggerAgentTurn, saveRuntimeSessionState, buildBoundedTurnTrail, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, renderCodingHostInboundPrompt, resolveHostWorkspaceCwd, upsertLocalRuntimeEntry, } from '@canonmsg/core';
 import { decideAutoReply, } from './inbound-policy.js';
 import { CodexConversationAdapter, } from './adapter.js';
 import { CodexAppServerAdapter } from './app-server-adapter.js';
@@ -19,7 +19,7 @@ import { startCodexStreamInBackground } from './host-lifecycle.js';
 import { createCodexControlPoller } from './control-channel.js';
 import { runCli } from './cli-entry.js';
 import { collectMissedInboundMessages, STARTUP_RECOVERY_MAX_MESSAGES, STARTUP_RECOVERY_PAGE_SIZE, } from './startup-recovery.js';
-import { beginCommandBlock, claimCommandBlock, createCommandBlockTracker, } from './turn-activity.js';
+import { applyTextSegmentBlock, beginCommandBlock, claimCommandBlock, createCommandBlockTracker, } from './turn-activity.js';
 const HELP = `canon-codex — run a local Codex agent host for Canon
 
 USAGE
@@ -53,6 +53,14 @@ Keep this terminal open while you want Canon to reach the agent. Closing it,
 logging out, rebooting, or sleeping long enough to stop the process takes the
 local agent offline until you revive it. Docs:
 https://canonmail.com/agents/integrations`;
+export function buildCodexInitialSessionState(input) {
+    return {
+        model: input.model,
+        permissionMode: input.permissionMode,
+        ...(input.effort ? { effort: input.effort } : {}),
+        state: 'idle',
+    };
+}
 const MAX_SESSIONS = 12;
 const IDLE_TIMEOUT_MS = 30 * 60 * 1000;
 const HEARTBEAT_MS = 30_000;
@@ -248,7 +256,7 @@ function resolveCodexEffectiveRuntimePolicy(input) {
     };
 }
 function buildCanonPrompt(input) {
-    return renderCanonTurnBriefPrompt(buildCanonTurnContextV2({
+    return renderCodingHostInboundPrompt(buildCanonInboundFrameV1(buildCanonTurnContextV2({
         content: input.content,
         conversationId: input.conversationId,
         participantContext: input.participantContext,
@@ -257,9 +265,8 @@ function buildCanonPrompt(input) {
         activeSelfContextId: input.activeSelfContextId,
         provenance: input.provenance,
         replyContext: input.replyContext,
-        sessionContextLines: input.sessionContextLines,
         message: input.message,
-    }));
+    })));
 }
 function renderInboundContent(message, materialized) {
     return renderCanonHostInboundContent(message, materialized);
@@ -668,6 +675,18 @@ export async function main() {
             blocks: session.turnBlocks,
         }).catch(() => { });
     }
+    function upsertCodexTextSegment(session, event) {
+        const next = applyTextSegmentBlock({
+            turnLiveText: session.turnLiveText,
+            turnBlocks: session.turnBlocks,
+        }, {
+            turnId: session.currentTurnId,
+            itemId: event.itemId,
+            text: event.text,
+        });
+        session.turnLiveText = next.turnLiveText;
+        session.turnBlocks = next.turnBlocks;
+    }
     function upsertTurnBlock(session, block) {
         const now = Date.now();
         const index = session.turnBlocks.findIndex((existing) => existing.id === block.id);
@@ -867,11 +886,11 @@ export async function main() {
                     adapter,
                     queue: [],
                     running: false,
-                    state: {
+                    state: buildCodexInitialSessionState({
                         model: policy.model,
                         permissionMode: policy.permissionMode,
-                        state: 'idle',
-                    },
+                        effort: initialEffort,
+                    }),
                     policyFingerprint: policy.fingerprint,
                     turnState: 'idle',
                     currentTurnId: null,
@@ -907,8 +926,17 @@ export async function main() {
             pendingSessionCreations.delete(conversationId);
         }
     }
-    function enqueuePrompt(session, prompt, intent = 'queue', toFront = false, sourceMessageId, markAccepted = false, imagePaths = [], mediaAddDirs = [], planMode = false) {
-        const nextPrompt = { prompt, intent, sourceMessageId, markAccepted, imagePaths, mediaAddDirs, planMode };
+    function enqueuePrompt(session, prompt, intent = 'queue', toFront = false, sourceMessageId, markAccepted = false, imagePaths = [], mediaAddDirs = [], planMode = false, artifactRoutingMode = 'disabled') {
+        const nextPrompt = {
+            prompt,
+            intent,
+            sourceMessageId,
+            markAccepted,
+            imagePaths,
+            mediaAddDirs,
+            planMode,
+            artifactRoutingMode,
+        };
         if (toFront) {
             session.queue.unshift(nextPrompt);
         }
@@ -919,6 +947,11 @@ export async function main() {
         writeTurn(session);
         void runNextTurn(session);
     }
+    function resolveArtifactRoutingMode(participantContext) {
+        return participantContext.conversationType === 'direct' && participantContext.isOwner
+            ? 'workspace-generated'
+            : 'disabled';
+    }
     async function waitForRuntimeInputResponse(input) {
         while (Date.now() < input.expiresAt) {
             const response = await client.consumeRuntimeInputResponse({
@@ -1291,43 +1324,50 @@ export async function main() {
             message: input.message,
         });
         if (session.running && deliveryIntent === 'interrupt') {
-            enqueuePrompt(session, prompt, deliveryIntent, true, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode);
+            const artifactRoutingMode = resolveArtifactRoutingMode(participantContext);
+            enqueuePrompt(session, prompt, deliveryIntent, true, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode, artifactRoutingMode);
             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;
         }
-        enqueuePrompt(session, prompt, deliveryIntent, false, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode);
+        const artifactRoutingMode = resolveArtifactRoutingMode(participantContext);
+        enqueuePrompt(session, prompt, deliveryIntent, false, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode, artifactRoutingMode);
+    }
+    function sendTurnArtifactFile(session, file) {
+        return sendMediaFileMessage(client, session.conversationId, file.path, '', {
+            ...(session.activeSelfContextId ? { selfContextId: session.activeSelfContextId } : {}),
+            metadata: {
+                ...(session.currentTurnId ? { turnId: session.currentTurnId } : {}),
+                // Media is permanent conversation content (promoted like a final
+                // reply) but must never re-trigger other agents — the host's own
+                // final text message stays the only turn-complete trigger.
+                turnSemantics: 'turn_complete',
+                replyBehavior: 'suppress_auto_reply',
+            },
+        });
     }
-    async function routeSessionArtifacts(session, artifactDir) {
-        if (!artifactDir)
+    async function routeWorkspaceGeneratedArtifacts(session, baseline) {
+        if (!baseline)
             return;
         const logPrefix = `[canon-codex] [${session.conversationId.slice(0, 8)}]`;
         try {
-            const result = await flushTurnArtifacts({
-                artifactDir,
-                send: (file) => sendMediaFileMessage(client, session.conversationId, file.path, '', {
-                    ...(session.activeSelfContextId ? { selfContextId: session.activeSelfContextId } : {}),
-                    metadata: {
-                        ...(session.currentTurnId ? { turnId: session.currentTurnId } : {}),
-                        // Media is permanent conversation content (promoted like a final
-                        // reply) but must never re-trigger other agents — the host's own
-                        // final text message stays the only turn-complete trigger.
-                        turnSemantics: 'turn_complete',
-                        replyBehavior: 'suppress_auto_reply',
-                    },
-                }),
+            const result = await collectTurnArtifacts({
+                cwd: session.cwd,
+                baseline,
             });
-            for (const entry of result.sent) {
-                console.error(`${logPrefix} Routed artifact ${entry.file.fileName} (${entry.messageId})`
-                    + (entry.removeFailed ? '; removal failed, so it may resend later' : ''));
-            }
-            for (const failure of result.failed) {
-                console.error(`${logPrefix} Artifact upload failed for ${failure.file.fileName}; left in place: ${failure.error}`);
+            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 === 'unsupported') {
+                if (skipped.reason === 'too-large' || skipped.reason === 'file-cap' || skipped.reason === 'scan-limit') {
                     console.error(`${logPrefix} Artifact skipped ${skipped.fileName} (${skipped.reason})`);
                 }
             }
@@ -1361,19 +1401,26 @@ export async function main() {
         // Status-only seed: 'thinking' renders as a working filament row on the
         // clients; text here would be bubbled as speech (v4 register rule).
         writeCodexStreaming(session, '', 'thinking');
-        let artifactDir = null;
+        let artifactBaseline = null;
         let artifactsRouted = false;
         const routeArtifactsOnce = async () => {
             if (artifactsRouted)
                 return;
             artifactsRouted = true;
-            await routeSessionArtifacts(session, artifactDir);
+            if (nextTurn.artifactRoutingMode === 'workspace-generated') {
+                await routeWorkspaceGeneratedArtifacts(session, artifactBaseline);
+            }
         };
         try {
             const turnId = session.currentTurnId ?? randomUUID();
             session.currentTurnId = turnId;
-            artifactDir = await ensureTurnArtifactDir(session.cwd, turnId);
-            const turnPrompt = `${nextTurn.prompt}\n\n${buildTurnArtifactContextLine(artifactDir)}`;
+            let turnPrompt = nextTurn.prompt;
+            if (nextTurn.artifactRoutingMode === 'workspace-generated') {
+                artifactBaseline = await captureTurnArtifactSnapshot({ cwd: session.cwd }).catch((error) => {
+                    console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Artifact snapshot failed:`, error instanceof Error ? error.message : error);
+                    return null;
+                });
+            }
             const modelGuard = buildCodexModelGuardMessage(session.state.model, codexCliStatus);
             if (modelGuard) {
                 throw new ExecutionEnvironmentError(modelGuard, modelGuard);
@@ -1395,7 +1442,8 @@ export async function main() {
                     markTurnProgress(session);
                     writeTurn(session);
                     stopVisibleWorkSignal(session);
-                    writeCodexStreaming(session, event.text, 'streaming');
+                    upsertCodexTextSegment(session, event);
+                    writeCodexStreaming(session, null, 'streaming');
                     return;
                 }
                 if (event.type === 'plan.updated') {
@@ -1824,7 +1872,7 @@ export async function main() {
                         {
                             id: 'mediaOut',
                             label: 'Media out',
-                            value: 'Explicit turn artifact directory',
+                            value: 'Generated media artifacts',
                         },
                     ],
                     execution: {

package/dist/turn-activity.d.ts

@@ -1,3 +1,4 @@
+import type { TurnOutputBlock } from '@canonmsg/core';
 interface RunningCommandBlock {
     command: string;
     blockId: string;
@@ -7,7 +8,17 @@ export interface CommandBlockTracker {
     sequence: number;
     running: RunningCommandBlock[];
 }
+export interface TextSegmentBlockState {
+    turnLiveText: string;
+    turnBlocks: TurnOutputBlock[];
+}
 export declare function createCommandBlockTracker(): CommandBlockTracker;
+export declare function applyTextSegmentBlock(state: TextSegmentBlockState, input: {
+    turnId: string | null | undefined;
+    itemId?: string;
+    text: string;
+    now?: number;
+}): TextSegmentBlockState;
 export declare function beginCommandBlock(tracker: CommandBlockTracker, input: {
     turnId: string | null | undefined;
     command: string;

package/dist/turn-activity.js

@@ -8,6 +8,49 @@ function normalizeOptionalString(value) {
     const normalized = value?.trim();
     return normalized ? normalized : undefined;
 }
+function textBlockId(turnId, itemId) {
+    return `message:${turnId ?? 'turn'}:${normalizeOptionalString(itemId) ?? 'latest'}`;
+}
+function buildLiveText(blocks) {
+    return blocks
+        .filter((block) => block.kind === 'text' && block.text?.trim())
+        .sort((left, right) => {
+        if (left.sequence !== right.sequence)
+            return left.sequence - right.sequence;
+        return left.id.localeCompare(right.id);
+    })
+        .map((block) => block.text)
+        .join('\n\n');
+}
+export function applyTextSegmentBlock(state, input) {
+    const id = textBlockId(input.turnId, input.itemId);
+    const now = input.now ?? Date.now();
+    const index = state.turnBlocks.findIndex((block) => block.id === id);
+    const existing = index >= 0 ? state.turnBlocks[index] : null;
+    const next = {
+        ...(existing ?? {
+            sequence: state.turnBlocks.length + 1,
+            createdAt: now,
+        }),
+        id,
+        turnId: input.turnId ?? id,
+        kind: 'text',
+        status: existing?.status ?? 'running',
+        text: input.text,
+        updatedAt: now,
+    };
+    const turnBlocks = index >= 0
+        ? [
+            ...state.turnBlocks.slice(0, index),
+            next,
+            ...state.turnBlocks.slice(index + 1),
+        ]
+        : [...state.turnBlocks, next];
+    return {
+        turnBlocks,
+        turnLiveText: buildLiveText(turnBlocks) || state.turnLiveText,
+    };
+}
 function nextCommandBlockId(tracker, turnId, itemId) {
     const stableTurnId = turnId ?? 'turn';
     if (itemId)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.18.4",
+  "version": "0.18.6",
   "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": "^3.2.3",
-    "@canonmsg/coding-agent-host": "^0.2.0",
-    "@canonmsg/core": "^2.6.0"
+    "@canonmsg/agent-sdk": "^3.3.1",
+    "@canonmsg/coding-agent-host": "^0.2.2",
+    "@canonmsg/core": "^2.8.1"
   },
   "engines": {
     "node": ">=18.0.0"