sneakoscope 7.3.0 → 7.6.0

package/dist/core/remote/codex-public-activity.js

@@ -0,0 +1,283 @@
+import path from 'node:path';
+import { asRecordOrNull as asRecord } from '../json/records.js';
+import { redactString } from '../secret-redaction.js';
+import { redactRemoteValue } from './audit-idempotency.js';
+const PUBLIC_DETAIL_BYTES = 2 * 1024;
+export function publicCodexActivityFromItem(value, projectRoot) {
+    const item = asRecord(value);
+    if (!item)
+        return null;
+    const type = String(item.type || '');
+    const status = publicStatus(item.status);
+    const duration = publicInteger(item.durationMs);
+    if (type === 'commandExecution') {
+        return {
+            kind: 'command',
+            status,
+            title: 'Command execution',
+            detail: publicCommandSummary(item.command),
+            duration_ms: duration,
+            exit_code: publicInteger(item.exitCode)
+        };
+    }
+    if (type === 'fileChange') {
+        const changes = Array.isArray(item.changes) ? item.changes.map(asRecord).filter(Boolean) : [];
+        const paths = changes
+            .map((change) => publicProjectPath(change.path, projectRoot))
+            .filter((entry) => Boolean(entry))
+            .slice(0, 12);
+        const omitted = Math.max(0, changes.length - paths.length);
+        return {
+            kind: 'file_change',
+            status,
+            title: `${changes.length} file change${changes.length === 1 ? '' : 's'}`,
+            detail: paths.length
+                ? `${paths.join(', ')}${omitted ? ` · +${omitted} more` : ''}`
+                : null,
+            duration_ms: null,
+            exit_code: null
+        };
+    }
+    if (type === 'mcpToolCall') {
+        const server = publicCodexText(item.server, 120);
+        const tool = publicCodexText(item.tool, 160);
+        return {
+            kind: 'mcp_tool',
+            status,
+            title: [server, tool].filter(Boolean).join('.') || 'MCP tool',
+            detail: asRecord(item.error) ? 'Tool reported an error.' : null,
+            duration_ms: duration,
+            exit_code: null
+        };
+    }
+    if (type === 'dynamicToolCall') {
+        const namespace = publicCodexText(item.namespace, 120);
+        const tool = publicCodexText(item.tool, 160);
+        return {
+            kind: 'dynamic_tool',
+            status,
+            title: [namespace, tool].filter(Boolean).join('.') || 'Dynamic tool',
+            detail: item.success === false ? 'Tool reported failure.' : null,
+            duration_ms: duration,
+            exit_code: null
+        };
+    }
+    if (type === 'collabAgentToolCall') {
+        const receivers = Array.isArray(item.receiverThreadIds) ? item.receiverThreadIds.length : 0;
+        return {
+            kind: 'subagent_tool',
+            status,
+            title: `Subagent ${publicCodexText(item.tool, 120) || 'activity'}`,
+            detail: receivers ? `${receivers} target${receivers === 1 ? '' : 's'}` : null,
+            duration_ms: null,
+            exit_code: null
+        };
+    }
+    if (type === 'subAgentActivity') {
+        return {
+            kind: 'subagent',
+            status: publicStatus(item.kind),
+            title: `Subagent ${publicCodexText(item.kind, 80) || 'activity'}`,
+            detail: null,
+            duration_ms: null,
+            exit_code: null
+        };
+    }
+    if (type === 'webSearch') {
+        const action = asRecord(item.action);
+        const queryCount = Array.isArray(action?.queries)
+            ? action.queries.length
+            : item.query || action?.query
+                ? 1
+                : 0;
+        return {
+            kind: 'web_search',
+            status,
+            title: 'Web search',
+            detail: queryCount > 0 ? `${queryCount} bounded search request${queryCount === 1 ? '' : 's'}` : null,
+            duration_ms: null,
+            exit_code: null
+        };
+    }
+    if (type === 'plan') {
+        return {
+            kind: 'plan',
+            status,
+            title: 'Plan updated',
+            detail: null,
+            duration_ms: null,
+            exit_code: null
+        };
+    }
+    if (type === 'contextCompaction') {
+        return {
+            kind: 'compaction',
+            status: 'completed',
+            title: 'Context compacted',
+            detail: null,
+            duration_ms: null,
+            exit_code: null
+        };
+    }
+    if (type === 'imageGeneration') {
+        return {
+            kind: 'image_generation',
+            status,
+            title: 'Image generation',
+            detail: null,
+            duration_ms: duration,
+            exit_code: null
+        };
+    }
+    if (type === 'imageView') {
+        return {
+            kind: 'image_view',
+            status,
+            title: 'Image inspected',
+            detail: null,
+            duration_ms: null,
+            exit_code: null
+        };
+    }
+    if (type === 'sleep') {
+        return {
+            kind: 'wait',
+            status,
+            title: 'Waiting',
+            detail: null,
+            duration_ms: duration,
+            exit_code: null
+        };
+    }
+    if (type === 'enteredReviewMode' || type === 'exitedReviewMode') {
+        return {
+            kind: 'review',
+            status,
+            title: type === 'enteredReviewMode' ? 'Review started' : 'Review completed',
+            detail: null,
+            duration_ms: null,
+            exit_code: null
+        };
+    }
+    return null;
+}
+export function publicCodexJournalEvent(value, expectedThreadId, projectRoot) {
+    const event = asRecord(value);
+    const method = String(event?.method || '');
+    if (!['turn/started', 'turn/completed', 'item/started', 'item/completed'].includes(method))
+        return null;
+    const params = asRecord(event?.params);
+    const threadId = publicIdentifier(params?.threadId, 200);
+    if (!threadId || !expectedThreadId || threadId !== expectedThreadId)
+        return null;
+    const turn = asRecord(params?.turn);
+    const turnId = publicIdentifier(params?.turnId ?? turn?.id, 200);
+    if (!turnId)
+        return null;
+    if (method === 'turn/started' || method === 'turn/completed') {
+        const lifecycle = method.endsWith('started') ? 'started' : 'completed';
+        const status = publicStatus(turn?.status || lifecycle);
+        return {
+            type: lifecycle === 'started' ? 'codex.turn.started' : 'codex.turn.completed',
+            dedupe_key: `turn:${turnId}:${lifecycle}`,
+            turn_id: turnId,
+            item_id: null,
+            summary: {
+                thread_id: threadId,
+                turn_id: turnId,
+                kind: 'turn',
+                status,
+                title: lifecycle === 'started' ? 'Codex turn started' : `Codex turn ${status}`,
+                detail: null,
+                duration_ms: publicInteger(turn?.durationMs),
+                exit_code: null
+            }
+        };
+    }
+    const item = asRecord(params?.item);
+    const itemId = publicIdentifier(item?.id, 240);
+    const activity = publicCodexActivityFromItem(item, projectRoot);
+    if (!itemId || !activity)
+        return null;
+    const lifecycle = method.endsWith('started') ? 'started' : 'completed';
+    return {
+        type: lifecycle === 'started' ? 'codex.item.started' : 'codex.item.completed',
+        dedupe_key: `item:${itemId}:${lifecycle}`,
+        turn_id: turnId,
+        item_id: itemId,
+        summary: {
+            thread_id: threadId,
+            turn_id: turnId,
+            item_id: itemId,
+            item_type: String(item?.type || 'unknown').slice(0, 80),
+            ...activity
+        }
+    };
+}
+export function publicCodexText(value, maxBytes = PUBLIC_DETAIL_BYTES) {
+    if (typeof value !== 'string')
+        return null;
+    let text = redactString(String(redactRemoteValue(value)))
+        .replace(/\bgh[pousr]_[A-Za-z0-9_]{20,}\b/g, '[REDACTED]')
+        .replace(/\bgithub_pat_[A-Za-z0-9_]{20,}\b/g, '[REDACTED]')
+        .replace(/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g, '[REDACTED]')
+        .replace(/\bBearer\s+[A-Za-z0-9._~+/=-]{12,}\b/gi, 'Bearer [REDACTED]')
+        .replace(/((?:api[_-]?key|token|secret|password|passwd|authorization)\s*[:=]\s*)[^\s"',}]+/gi, '$1[REDACTED]')
+        .replace(/([?&](?:api[_-]?key|token|secret|password)=)[^&#\s]+/gi, '$1[REDACTED]')
+        .replace(/(?:\/Users|\/home|\/private|\/Volumes|\/etc|\/root)\/[^\s"'`]+(?:\/[^\s"'`]*)?/g, '[path-redacted]')
+        .replace(/\b[A-Za-z]:\\(?:[^\\\s"'`]+\\)*[^\\\s"'`]*/g, '[path-redacted]')
+        .trim();
+    if (!text)
+        return null;
+    if (Buffer.byteLength(text, 'utf8') <= maxBytes)
+        return text;
+    const suffix = '…';
+    const budget = Math.max(0, maxBytes - Buffer.byteLength(suffix, 'utf8'));
+    text = Buffer.from(text, 'utf8').subarray(0, budget).toString('utf8').replace(/\uFFFD+$/g, '');
+    return `${text}${suffix}`;
+}
+function publicProjectPath(value, projectRoot) {
+    if (typeof value !== 'string' || !value.trim())
+        return null;
+    const absolute = path.isAbsolute(value) ? path.resolve(value) : path.resolve(projectRoot, value);
+    const relative = path.relative(path.resolve(projectRoot), absolute);
+    if (!relative || relative === '.')
+        return path.basename(projectRoot);
+    if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
+        return '[outside-project]';
+    return publicCodexText(relative.split(path.sep).join('/'), 480);
+}
+function publicCommandSummary(value) {
+    if (typeof value !== 'string')
+        return null;
+    const tokens = value.trim().split(/\s+/).filter(Boolean);
+    while (tokens[0] && /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[0]))
+        tokens.shift();
+    if (tokens[0] && path.basename(tokens[0]) === 'env') {
+        tokens.shift();
+        while (tokens[0] && /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[0]))
+            tokens.shift();
+    }
+    const executable = tokens[0]
+        ? path.basename(tokens[0]).replace(/[^A-Za-z0-9._+-]/g, '').slice(0, 80)
+        : '';
+    if (!executable)
+        return null;
+    const safeSubcommands = new Set([
+        'build', 'check', 'diff', 'install', 'lint', 'list', 'run', 'status',
+        'test', 'typecheck', 'verify', '--check', '--version', '-v'
+    ]);
+    const subcommand = tokens.slice(1, 3).find((token) => safeSubcommands.has(token));
+    return `Executable: ${executable}${subcommand ? ` · ${subcommand}` : ''}`;
+}
+function publicStatus(value) {
+    const text = typeof value === 'string' ? value.trim() : '';
+    return text && /^[A-Za-z][A-Za-z0-9._-]{0,63}$/.test(text) ? text : 'unknown';
+}
+function publicIdentifier(value, maxLength) {
+    const text = typeof value === 'string' ? value.trim() : '';
+    return text && text.length <= maxLength && /^[A-Za-z0-9][A-Za-z0-9._:/-]*$/.test(text) ? text : null;
+}
+function publicInteger(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) ? value : null;
+}

package/dist/core/remote/index.js

@@ -7,6 +7,7 @@ export * from './owner-proof.js';
 export * from './protocol.js';
 export * from './session-snapshot.js';
 export * from './session-binding.js';
+export * from './codex-public-activity.js';
 export * from './worker.js';
 export * from './ssh-worker-client.js';
 export * from './local-worker-client.js';

package/dist/core/remote/ssh-worker-client.js

@@ -22,6 +22,7 @@ export class RemoteSshWorkerClient {
     projectId;
     sshCommand;
     requestTimeoutMs;
+    commandRequestTimeoutMs;
     maxResponseLineBytes;
     maxConnectionOutputBytes;
     reconnectAttempts;
@@ -46,6 +47,8 @@ export class RemoteSshWorkerClient {
         this.projectId = options.projectId;
         this.sshCommand = options.sshCommand ?? 'ssh';
         this.requestTimeoutMs = Math.max(1_000, options.requestTimeoutMs ?? 30_000);
+        this.commandRequestTimeoutMs = Math.max(1_000, options.commandRequestTimeoutMs
+            ?? (options.requestTimeoutMs === undefined ? 31 * 60_000 : options.requestTimeoutMs));
         this.maxResponseLineBytes = Math.max(4_096, options.maxResponseLineBytes ?? 512 * 1024);
         this.maxConnectionOutputBytes = Math.max(this.maxResponseLineBytes, options.maxConnectionOutputBytes ?? 8 * 1024 * 1024);
         this.reconnectAttempts = Math.max(1, Math.min(10, options.reconnectAttempts ?? 4));
@@ -167,7 +170,7 @@ export class RemoteSshWorkerClient {
                 const delivery = pending?.dispatched ? 'unknown' : 'not_dispatched';
                 reject(new RemoteSshClientError(delivery === 'unknown' ? 'delivery_unknown' : 'disconnected_before_dispatch', delivery, delivery === 'not_dispatched' || request.type !== 'command'));
                 this.abortConnection('ssh_request_timeout');
-            }, this.requestTimeoutMs);
+            }, request.type === 'command' ? this.commandRequestTimeoutMs : this.requestTimeoutMs);
             timer.unref?.();
             const pending = { request, resolve, reject, timer, dispatched: false };
             this.pending.set(request.id, pending);

package/dist/core/remote/worker.js

@@ -1,7 +1,8 @@
 import crypto from 'node:crypto';
 import fsp from 'node:fs/promises';
 import path from 'node:path';
-import { createCodexAppServerV2Client } from '../codex-control/codex-app-server-v2-client.js';
+import { CodexAppServerRequestError, createCodexAppServerV2Client } from '../codex-control/codex-app-server-v2-client.js';
+import { CodexAppServerRuntimeEnvError, prepareCodexAppServerRuntimeEnv } from '../codex-control/codex-app-server-runtime-env.js';
 import { RemoteAuditLog, RemoteCommandLedger, RemoteEventJournal, remoteRuntimePaths } from './audit-idempotency.js';
 import { cancelOwnedSession, parseRemoteCancelPayload, RemoteOwnerProofError, RemoteOwnerProofStore } from './owner-proof.js';
 import { RemoteProtocolError, workerErrorResponse, workerSuccessResponse } from './protocol.js';
@@ -9,6 +10,12 @@ import { RemoteCodexSessionBindingStore, readRemoteCodexBindingSnapshot, remoteC
 import { listRemoteSessionRows, readRemoteSessionView, readRemoteSessionSnapshot, remoteSessionGeneration, remoteSessionRecord } from './session-snapshot.js';
 import { REMOTE_COMMAND_RECEIPT_SCHEMA } from './types.js';
 import { asRecordOrNull as asRecord } from '../json/records.js';
+import { publicCodexJournalEvent } from './codex-public-activity.js';
+const MAX_PUBLIC_CODEX_JOURNAL_EVENTS_PER_TURN = 256;
+const PUBLIC_CODEX_JOURNAL_FLUSH_BATCH_SIZE = 8;
+const PUBLIC_CODEX_JOURNAL_FLUSH_INTERVAL_MS = 400;
+const PUBLIC_CODEX_JOURNAL_FLUSH_DEADLINE_MS = 750;
+const TELEGRAM_CODEX_DEVELOPER_INSTRUCTIONS = 'This is a dedicated private Telegram coding thread. Work only inside the configured project workspace, never expose secrets, and return a concise user-facing final response for each turn.';
 export class RemoteWorkerExecutionError extends Error {
     code;
     delivery;
@@ -41,7 +48,10 @@ export class RemoteWorker {
         const paths = remoteRuntimePaths(this.root);
         this.commands = options.commandLedger ?? new RemoteCommandLedger(paths.commands, { lockPath: paths.commandLock });
         this.audit = options.audit ?? new RemoteAuditLog(paths.audit);
-        this.events = options.events ?? new RemoteEventJournal(paths.events, { lockPath: paths.eventLock });
+        this.events = options.events ?? new RemoteEventJournal(paths.events, {
+            lockPath: paths.eventLock,
+            healthPath: paths.eventHealth
+        });
         this.owners = options.owners ?? new RemoteOwnerProofStore(paths.owners);
         this.bindings = options.bindings ?? new RemoteCodexSessionBindingStore(remoteCodexSessionBindingsPath(this.root));
         this.codexClientFactory = options.codexClientFactory ?? defaultCodexClientFactory;
@@ -295,7 +305,9 @@ export class RemoteWorker {
             if (!owner.codex_thread_id || !owner.active_turn_id)
                 throw new RemoteWorkerExecutionError('codex_turn_binding_missing');
             const client = await this.codexClientFactory(this.root).catch((err) => {
-                void err;
+                if (err instanceof CodexAppServerRuntimeEnvError) {
+                    throw new RemoteWorkerExecutionError(err.code, 'not_dispatched', true);
+                }
                 throw new RemoteWorkerExecutionError('codex_app_server_unavailable', 'not_dispatched', true);
             });
             try {
@@ -306,7 +318,7 @@ export class RemoteWorker {
                     threadId: owner.codex_thread_id,
                     clientUserMessageId: crypto.randomUUID(),
                     expectedTurnId: owner.active_turn_id,
-                    input: [{ type: 'text', text, text_elements: [] }]
+                    input: [{ type: 'text', text }]
                 });
             }
             catch (err) {
@@ -397,14 +409,96 @@ export class RemoteWorker {
         }
     }
     async runDedicatedCodexTurn(binding, text) {
-        const client = await this.codexClientFactory(this.root).catch(() => {
+        const client = await this.codexClientFactory(this.root).catch((err) => {
+            if (err instanceof CodexAppServerRuntimeEnvError) {
+                throw new RemoteWorkerExecutionError(err.code, 'not_dispatched', true);
+            }
             throw new RemoteWorkerExecutionError('codex_app_server_unavailable', 'not_dispatched', true);
         });
         const threadWasPersisted = Boolean(binding.codex_thread_id);
         let threadId = binding.codex_thread_id;
         let turnId = null;
+        let disposeEvents = null;
+        let journalEventCount = 0;
+        let journalTruncationRecorded = false;
+        const journalEvents = [];
+        let journalFlushTimer = null;
+        let journalFlushFailure = null;
+        let journalFlushChain = Promise.resolve();
+        const flushJournalEvents = () => {
+            if (journalFlushTimer) {
+                clearTimeout(journalFlushTimer);
+                journalFlushTimer = null;
+            }
+            if (journalEvents.length === 0 || journalFlushFailure)
+                return journalFlushChain;
+            const batch = journalEvents.splice(0, journalEvents.length);
+            journalFlushChain = journalFlushChain.then(async () => {
+                if (journalFlushFailure)
+                    return;
+                const outcome = await settleWithin(this.events.appendMany(batch), PUBLIC_CODEX_JOURNAL_FLUSH_DEADLINE_MS);
+                if (outcome !== 'completed')
+                    journalFlushFailure = outcome;
+            });
+            return journalFlushChain;
+        };
+        const scheduleJournalFlush = () => {
+            if (journalFlushFailure || journalFlushTimer)
+                return;
+            if (journalEvents.length >= PUBLIC_CODEX_JOURNAL_FLUSH_BATCH_SIZE) {
+                void flushJournalEvents();
+                return;
+            }
+            journalFlushTimer = setTimeout(() => {
+                journalFlushTimer = null;
+                void flushJournalEvents();
+            }, PUBLIC_CODEX_JOURNAL_FLUSH_INTERVAL_MS);
+            journalFlushTimer.unref?.();
+        };
         try {
-            await client.initialize();
+            await client.initialize().catch((error) => {
+                throw codexStageExecutionError('initialize', error);
+            });
+            if (client.onEvent) {
+                disposeEvents = client.onEvent((event) => {
+                    const projected = publicCodexJournalEvent(event, threadId, this.root);
+                    if (!projected)
+                        return;
+                    if (journalEventCount >= MAX_PUBLIC_CODEX_JOURNAL_EVENTS_PER_TURN) {
+                        if (!journalTruncationRecorded) {
+                            journalTruncationRecorded = true;
+                            journalEvents.push({
+                                type: 'codex.activity.truncated',
+                                session_id: binding.session_id,
+                                command_id: null,
+                                summary: {
+                                    thread_id: threadId,
+                                    turn_id: projected.turn_id,
+                                    kind: 'activity',
+                                    status: 'truncated',
+                                    title: 'Live activity journal reached its per-turn limit',
+                                    detail: `Historical thread projection remains available after completion; live journal limit is ${MAX_PUBLIC_CODEX_JOURNAL_EVENTS_PER_TURN} events.`,
+                                    duration_ms: null,
+                                    exit_code: null
+                                }
+                            });
+                            scheduleJournalFlush();
+                        }
+                        return;
+                    }
+                    journalEventCount += 1;
+                    journalEvents.push({
+                        type: projected.type,
+                        session_id: binding.session_id,
+                        command_id: null,
+                        summary: {
+                            dedupe_key: projected.dedupe_key,
+                            ...projected.summary
+                        }
+                    });
+                    scheduleJournalFlush();
+                });
+            }
             if (!client.resumeThread || !client.startTurn || !client.readThread || !client.waitForTurnCompletion) {
                 throw new RemoteWorkerExecutionError('codex_app_server_session_api_unavailable', 'not_dispatched', false);
             }
@@ -414,7 +508,8 @@ export class RemoteWorker {
                         threadId,
                         cwd: this.root,
                         approvalPolicy: 'never',
-                        sandbox: 'workspace-write'
+                        sandbox: 'workspace-write',
+                        developerInstructions: TELEGRAM_CODEX_DEVELOPER_INSTRUCTIONS
                     }));
                     const resumedThread = asRecord(resumed?.thread);
                     if (String(resumedThread?.id ?? '') !== threadId)
@@ -436,6 +531,9 @@ export class RemoteWorker {
                         throw new RemoteWorkerExecutionError(missingRollout ? 'codex_thread_history_missing' : 'codex_thread_resume_failed', 'not_dispatched', !missingRollout);
                     }
                     if (!missingRollout) {
+                        if (isCodexAppServerContractError(err)) {
+                            throw new RemoteWorkerExecutionError('codex_thread_resume_contract_invalid', 'not_dispatched', false);
+                        }
                         throw new RemoteWorkerExecutionError('codex_thread_resume_failed', 'not_dispatched', true);
                     }
                     threadId = null;
@@ -449,14 +547,15 @@ export class RemoteWorker {
                     cwd: this.root,
                     approvalPolicy: 'never',
                     sandbox: 'workspace-write',
-                    threadSource: 'sks-telegram',
-                    baseInstructions: 'This is a dedicated private Telegram coding thread. Work only inside the configured project workspace, never expose secrets, and return a concise user-facing final response for each turn.'
-                }).catch(() => {
-                    throw new RemoteWorkerExecutionError('codex_thread_start_failed', 'not_dispatched', true);
+                    serviceName: 'sneakoscope_telegram',
+                    developerInstructions: TELEGRAM_CODEX_DEVELOPER_INSTRUCTIONS
+                }).catch((error) => {
+                    throw codexStageExecutionError('thread_start', error);
                 }));
                 threadId = stringValue(asRecord(started?.thread)?.id);
-                if (!threadId)
-                    throw new Error('codex_thread_start_missing_id');
+                if (!threadId) {
+                    throw new RemoteWorkerExecutionError('codex_thread_start_missing_id', 'unknown', false);
+                }
             }
             const started = asRecord(await client.startTurn({
                 threadId,
@@ -468,20 +567,29 @@ export class RemoteWorker {
                     networkAccess: false
                 },
                 clientUserMessageId: crypto.randomUUID(),
-                input: [{ type: 'text', text, text_elements: [] }]
+                input: [{ type: 'text', text }]
+            }).catch((error) => {
+                throw codexStageExecutionError('turn_start', error);
             }));
             turnId = stringValue(asRecord(started?.turn)?.id);
-            if (!turnId)
-                throw new Error('codex_turn_id_missing');
-            await client.waitForTurnCompletion(threadId, turnId, 30 * 60_000);
-            const read = asRecord(await client.readThread(threadId, true));
+            if (!turnId) {
+                throw new RemoteWorkerExecutionError('codex_turn_start_missing_id', 'unknown', false);
+            }
+            await client.waitForTurnCompletion(threadId, turnId, 30 * 60_000).catch(() => {
+                throw new RemoteWorkerExecutionError('codex_turn_completion_unknown', 'acknowledged', false);
+            });
+            const read = asRecord(await client.readThread(threadId, true).catch(() => {
+                throw new RemoteWorkerExecutionError('codex_turn_result_unavailable', 'acknowledged', false);
+            }));
             const thread = asRecord(read?.thread);
-            if (String(thread?.id ?? '') !== threadId)
-                throw new Error('codex_thread_read_mismatch');
+            if (String(thread?.id ?? '') !== threadId) {
+                throw new RemoteWorkerExecutionError('codex_thread_read_mismatch', 'acknowledged', false);
+            }
             const turns = Array.isArray(thread?.turns) ? thread.turns.map(asRecord).filter(Boolean) : [];
             const turn = turns.find((candidate) => String(candidate.id ?? '') === turnId);
-            if (!turn)
-                throw new Error('codex_completed_turn_missing');
+            if (!turn) {
+                throw new RemoteWorkerExecutionError('codex_completed_turn_missing', 'acknowledged', false);
+            }
             const turnStatus = String(turn.status ?? '');
             if (turnStatus !== 'completed') {
                 if (threadWasPersisted) {
@@ -501,9 +609,12 @@ export class RemoteWorker {
                 .map((item) => item.text)
                 .filter(Boolean)
                 .at(-1);
-            if (!finalMessage)
-                throw new Error('codex_final_agent_message_missing');
-            await this.bindings.recordTurn(binding.session_id, threadId, turnId, 'completed');
+            if (!finalMessage) {
+                throw new RemoteWorkerExecutionError('codex_final_response_missing', 'acknowledged', false);
+            }
+            await this.bindings.recordTurn(binding.session_id, threadId, turnId, 'completed').catch(() => {
+                throw new RemoteWorkerExecutionError('codex_session_binding_persist_failed', 'acknowledged', false);
+            });
             return {
                 accepted: true,
                 control: 'codex_app_server_v2',
@@ -519,15 +630,52 @@ export class RemoteWorker {
             if (threadWasPersisted && turnId && threadId) {
                 await this.bindings.recordTurn(binding.session_id, threadId, turnId, 'failed').catch(() => undefined);
             }
-            throw new RemoteWorkerExecutionError(turnId ? 'codex_turn_failed' : 'input_delivery_unknown', turnId ? 'acknowledged' : 'unknown', false);
+            throw new RemoteWorkerExecutionError(turnId ? 'codex_turn_failed' : 'codex_pre_dispatch_failed', turnId ? 'acknowledged' : 'not_dispatched', false);
         }
         finally {
+            disposeEvents?.();
+            if (journalFlushTimer) {
+                clearTimeout(journalFlushTimer);
+                journalFlushTimer = null;
+            }
+            const finalFlush = await settleWithin(flushJournalEvents(), PUBLIC_CODEX_JOURNAL_FLUSH_DEADLINE_MS * 2);
+            const flushFailure = journalFlushFailure
+                ?? (finalFlush === 'completed' ? null : finalFlush);
+            if (flushFailure) {
+                await settleWithin(this.audit.append({
+                    event: 'codex_public_activity_journal_failed',
+                    session_id: binding.session_id,
+                    turn_id: turnId,
+                    error_code: flushFailure === 'timed_out'
+                        ? 'remote_event_journal_flush_timed_out'
+                        : 'remote_event_journal_write_failed'
+                }), PUBLIC_CODEX_JOURNAL_FLUSH_DEADLINE_MS);
+            }
             await client.close().catch(() => undefined);
         }
     }
 }
+async function settleWithin(promise, timeoutMs) {
+    return await new Promise((resolve) => {
+        let settled = false;
+        const finish = (outcome) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(outcome);
+        };
+        const timer = setTimeout(() => finish('timed_out'), timeoutMs);
+        promise.then(() => finish('completed'), () => finish('failed'));
+    });
+}
 async function defaultCodexClientFactory(cwd) {
-    const created = await createCodexAppServerV2Client({ cwd, requestedBy: 'remote-worker' });
+    const env = await prepareCodexAppServerRuntimeEnv();
+    const created = await createCodexAppServerV2Client({
+        cwd,
+        env,
+        requestedBy: 'remote-worker'
+    });
     return created.client;
 }
 function normalizeExecutionError(err) {
@@ -555,3 +703,34 @@ function isMissingCodexRolloutError(error) {
     const message = error instanceof Error ? error.message : String(error);
     return /no rollout found for thread id|thread(?:\/resume)?:? (?:thread )?(?:not found|not loaded)/i.test(message);
 }
+function codexStageExecutionError(stage, error) {
+    const contractInvalid = isCodexAppServerContractError(error);
+    if (stage === 'initialize') {
+        return new RemoteWorkerExecutionError(contractInvalid
+            ? 'codex_app_server_initialize_contract_invalid'
+            : 'codex_app_server_initialize_failed', 'not_dispatched', !contractInvalid);
+    }
+    if (stage === 'thread_start') {
+        if (!isCodexAppServerMethodRejection(error, 'thread/start')) {
+            return new RemoteWorkerExecutionError('codex_thread_start_delivery_unknown', 'unknown', false);
+        }
+        return new RemoteWorkerExecutionError(contractInvalid ? 'codex_thread_start_contract_invalid' : 'codex_thread_start_failed', 'not_dispatched', false);
+    }
+    if (isCodexAppServerMethodRejection(error, 'turn/start')) {
+        return new RemoteWorkerExecutionError(contractInvalid ? 'codex_turn_start_contract_invalid' : 'codex_turn_start_rejected', 'not_dispatched', false);
+    }
+    return new RemoteWorkerExecutionError('codex_turn_start_delivery_unknown', 'unknown', false);
+}
+function isCodexAppServerContractError(error) {
+    if (error instanceof CodexAppServerRequestError && error.kind !== 'rpc_rejection')
+        return false;
+    const message = error instanceof Error ? error.message : String(error);
+    return /invalid request|unknown variant|unknown field|invalid type|requires experimentalapi capability|method not found/i.test(message);
+}
+function isCodexAppServerMethodRejection(error, method) {
+    if (error instanceof CodexAppServerRequestError) {
+        return error.kind === 'rpc_rejection' && error.method === method;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return message.trimStart().startsWith(`${method}:`);
+}

package/dist/core/research/research-adversarial-review.js

@@ -1,6 +1,7 @@
 import fsp from 'node:fs/promises';
 import path from 'node:path';
 import { nowIso, randomId, readJson, readText, sha256, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { uniqueValues as unique } from '../text/strings.js';
 import { buildOfficialSubagentPrompt } from '../subagents/official-subagent-prompt.js';
 import { codexAppSessionKey, detectCodexAppSession, runOfficialSubagentWorkflow } from '../subagents/official-subagent-runner.js';
 import { readOfficialSubagentConfig } from '../subagents/official-subagent-config.js';
@@ -1065,6 +1066,3 @@ function duplicates(values) {
     }
     return [...duplicates];
 }
-function unique(values) {
-    return [...new Set(values)];
-}