@canonmsg/codex-plugin 0.18.3 → 0.18.5

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,7 +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 { 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';
@@ -16,7 +17,6 @@ import { detectCodexCliVersion } from './codex-cli-version.js';
 import { buildCodexModelGuardMessage, formatCodexTurnFailure, isRecoverableCodexThreadError, } from './error-format.js';
 import { startCodexStreamInBackground } from './host-lifecycle.js';
 import { createCodexControlPoller } from './control-channel.js';
-import { buildOutboxContextLine, ensureOutboxDir, flushOutbox, resolveOutboxDir, } from './outbox.js';
 import { runCli } from './cli-entry.js';
 import { collectMissedInboundMessages, STARTUP_RECOVERY_MAX_MESSAGES, STARTUP_RECOVERY_PAGE_SIZE, } from './startup-recovery.js';
 import { beginCommandBlock, claimCommandBlock, createCommandBlockTracker, } from './turn-activity.js';
@@ -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);
@@ -867,11 +874,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,
@@ -889,7 +896,6 @@ export async function main() {
                 };
                 sessions.set(conversationId, session);
                 await controlPoller.baseline([conversationId]);
-                ensureOutboxDir(sessionCwd).catch((error) => console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Failed to create media outbox:`, error));
                 console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Environment → ${environment.mode} (${sessionCwd})`);
                 writeState(session);
                 writeTurn(session);
@@ -908,8 +914,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);
         }
@@ -920,6 +935,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({
@@ -1289,56 +1309,59 @@ export async function main() {
             activeSelfContextId,
             provenance: hydrated.provenance,
             replyContext,
-            sessionContextLines: [buildOutboxContextLine(session.cwd)],
             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);
     }
-    /**
-     * Turn-end media outbox flush (see ./outbox.ts for the convention). Never
-     * throws: upload failures are logged and the files stay in place for a
-     * later turn.
-     */
-    async function flushSessionOutbox(session) {
+    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 routeWorkspaceGeneratedArtifacts(session, baseline) {
+        if (!baseline)
+            return;
         const logPrefix = `[canon-codex] [${session.conversationId.slice(0, 8)}]`;
         try {
-            const result = await flushOutbox({
-                outboxDir: resolveOutboxDir(session.cwd),
-                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} Sent outbox file ${entry.file.fileName} (${entry.messageId})`
-                    + (entry.removeFailed ? ' — removal failed; it may resend next turn' : ''));
-            }
-            for (const failure of result.failed) {
-                console.error(`${logPrefix} Outbox 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') {
-                    console.error(`${logPrefix} Outbox skipped ${skipped.fileName} (${skipped.reason}); left in place`);
+                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} Outbox flush failed:`, error instanceof Error ? error.message : error);
+            console.error(`${logPrefix} Artifact routing failed:`, error instanceof Error ? error.message : error);
         }
     }
     async function runNextTurn(session) {
@@ -1366,7 +1389,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 artifactBaseline = null;
+        let artifactsRouted = false;
+        const routeArtifactsOnce = async () => {
+            if (artifactsRouted)
+                return;
+            artifactsRouted = true;
+            if (nextTurn.artifactRoutingMode === 'workspace-generated') {
+                await routeWorkspaceGeneratedArtifacts(session, artifactBaseline);
+            }
+        };
         try {
+            const turnId = session.currentTurnId ?? randomUUID();
+            session.currentTurnId = turnId;
+            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);
@@ -1470,7 +1512,7 @@ export async function main() {
                 clearStoredThreadId(runtimeId, agentId, session.conversationId, session.environment.baseCwd, session.environment.mode);
                 session.adapter.clearThreadId();
             };
-            const runTurnOnce = () => session.adapter.runTurn(nextTurn.prompt, handleCodexEvent, logCodexLine, turnImagePaths, turnMediaAddDirs, {
+            const runTurnOnce = () => session.adapter.runTurn(turnPrompt, handleCodexEvent, logCodexLine, turnImagePaths, turnMediaAddDirs, {
                 planMode: nextTurn.planMode,
                 onServerRequest: (request) => handleCodexServerRequest(session, request),
             });
@@ -1487,12 +1529,8 @@ export async function main() {
             if (result.threadId && !session.resetRequested) {
                 saveStoredThreadId(runtimeId, agentId, session.conversationId, session.environment.baseCwd, result.threadId, session.environment.mode, session.policyFingerprint);
             }
-            // Turn-end outbox flush — media lands before the final text reply.
-            // Interrupted turns keep their files for the next completed turn.
-            if (!result.interrupted) {
-                await flushSessionOutbox(session);
-            }
             if (!result.interrupted && result.finalMessage && nextTurn.planMode) {
+                await routeArtifactsOnce();
                 const planApproval = buildPlanApprovalRequest(session.currentTurnId ?? randomUUID(), 'Plan ready for review.', {
                     responseUserId: ownerId ?? undefined,
                     title: 'Codex Plan',
@@ -1514,6 +1552,7 @@ export async function main() {
                 if (isRecoverableCodexThreadError(result.errorText)) {
                     clearStoredThread();
                 }
+                await routeArtifactsOnce();
                 const turnTrail = buildFinalTurnTrail(session);
                 await sendMessageWithRetryChunked(client, session.conversationId, result.finalMessage, {
                     messageId: buildCodexMessageId(session, 'final'),
@@ -1531,6 +1570,7 @@ export async function main() {
                 console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Sent reply (${result.finalMessage.length} chars)`);
             }
             else if (!result.interrupted && result.exitCode && result.exitCode !== 0) {
+                await routeArtifactsOnce();
                 const userVisibleError = formatCodexTurnFailure(result.errorText);
                 session.state.lastError = userVisibleError;
                 writeState(session);
@@ -1553,6 +1593,7 @@ export async function main() {
                 await handoffFinalMessage(session.conversationId);
             }
             else if (!result.interrupted) {
+                await routeArtifactsOnce();
                 await handoffFinalMessage(session.conversationId);
             }
             else if (result.interrupted) {
@@ -1572,6 +1613,7 @@ export async function main() {
                     : `The Codex host failed during the turn: ${error instanceof Error ? error.message : String(error)}`;
             session.state.lastError = message;
             writeState(session);
+            await routeArtifactsOnce();
             await sendMessageWithRetryChunked(client, session.conversationId, message, {
                 messageId: buildCodexMessageId(session, 'failure'),
                 ...(session.activeSelfContextId
@@ -1817,7 +1859,7 @@ export async function main() {
                         {
                             id: 'mediaOut',
                             label: 'Media out',
-                            value: 'Turn-end outbox',
+                            value: 'Generated media artifacts',
                         },
                     ],
                     execution: {

package/package.json

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

package/dist/outbox.d.ts

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

package/dist/outbox.js

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