@kbediako/codex-orchestrator 0.2.0 → 0.2.1

package/dist/orchestrator/src/cli/codexDefaultsSetup.js

@@ -4,18 +4,25 @@ import { createRequire } from 'node:module';
 import { join } from 'node:path';
 import process from 'node:process';
 import { resolveCodexHome } from './utils/codexPaths.js';
+import { resolveCodexCliBin } from './utils/codexCli.js';
+import { codexFeatureProbeDisablesMultiAgentV2, codexFeatureProbeRejectsAgentMaxThreads, readCodexFeatureProbe } from './utils/codexFeatures.js';
 import { findPackageRoot } from './utils/packageInfo.js';
 import { writeAtomicFile } from '../utils/atomicWrite.js';
 const require = createRequire(import.meta.url);
 let tomlLibrary;
 export const BASELINE_MODEL = 'gpt-5.4';
 export const BASELINE_REVIEW_MODEL = BASELINE_MODEL;
+export const CURRENT_CHATGPT_MODEL = 'gpt-5.5';
 export const BASELINE_REASONING = 'xhigh';
 export const BASELINE_REASONING_MINIMUM = 'high';
 export const BASELINE_AGENTS = {
     max_threads: 12,
     max_depth: 4
 };
+export const LOCAL_MODEL_OPT_INS = [CURRENT_CHATGPT_MODEL];
+const LOCAL_MODEL_OPT_IN_SET = new Set(LOCAL_MODEL_OPT_INS);
+const CODEX_ORCHESTRATOR_CONFIG_KEY = 'codex_orchestrator';
+const LOCAL_MODEL_OPT_IN_CONFIG_KEY = 'local_model_opt_in';
 const ROLE_DEFINITIONS = [
     {
         key: 'explorer_fast',
@@ -29,26 +36,45 @@ const ROLE_DEFINITIONS = [
         description: 'Complex implementation role.',
         fileName: 'worker-complex.toml',
         configFile: './agents/worker-complex.toml',
-        templatePath: join('templates', 'codex', '.codex', 'agents', 'worker-complex.toml')
+        templatePath: join('templates', 'codex', '.codex', 'agents', 'worker-complex.toml'),
+        managedMigrationBaselines: [{ model: 'gpt-5.5', modelReasoningEffort: 'xhigh' }]
     },
     {
         key: 'awaiter',
         description: 'Awaiter override (keeps awaiter behavior with latest codex/high reasoning).',
         fileName: 'awaiter-high.toml',
         configFile: './agents/awaiter-high.toml',
-        templatePath: join('templates', 'codex', '.codex', 'agents', 'awaiter-high.toml')
+        templatePath: join('templates', 'codex', '.codex', 'agents', 'awaiter-high.toml'),
+        managedMigrationBaselines: [{ model: 'gpt-5.5', modelReasoningEffort: 'xhigh' }],
+        managedMigrationContentVariants: [
+            {
+                model: 'gpt-5.5',
+                modelReasoningEffort: 'high',
+                overrideComment: '# with CO portable override to use gpt-5.4 at high reasoning.'
+            }
+        ]
     }
 ];
 export async function runCodexDefaultsSetup(options = {}) {
     const env = options.env ?? process.env;
     const force = Boolean(options.force);
     const apply = Boolean(options.apply);
-    const plan = buildPlan(env, force);
+    const configState = await loadConfigState(buildConfigPath(env));
+    const topLevelLocalModelOptIn = resolveRequestedLocalModelOptIn(configState.parsed, options.authScope);
+    const roleAndReviewLocalModelOptIn = resolveRoleAndReviewLocalModelOptIn(configState.parsed, topLevelLocalModelOptIn, options.authScope);
+    const authScope = topLevelLocalModelOptIn ? 'chatgpt' : 'portable';
+    const plan = buildPlan(env, force, authScope);
     const roleDefinitions = await loadRoleDefinitions();
-    const configState = await loadConfigState(plan.configPath);
-    const nextConfig = mergeBaselineDefaults(configState.parsed, roleDefinitions);
+    const featureProbe = readCodexFeatureProbe(resolveCodexCliBin(env), env);
+    const nextConfig = mergeBaselineDefaults(configState.parsed, roleDefinitions, {
+        topLevelLocalModelOptIn,
+        reviewModelOptIn: roleAndReviewLocalModelOptIn,
+        requestedAuthScope: options.authScope,
+        featureProbe
+    });
+    const activeRoleDefinitions = buildActiveRoleDefinitions(roleDefinitions, roleAndReviewLocalModelOptIn);
     const configChanged = canonicalizeConfigValue(configState.parsed) !== canonicalizeConfigValue(nextConfig);
-    const roleChanges = await planRoleChanges(plan.agentsDir, force, roleDefinitions);
+    const roleChanges = await planRoleChanges(plan.agentsDir, force, activeRoleDefinitions);
     if (!apply) {
         const changes = buildPlannedChanges({
             configPath: plan.configPath,
@@ -72,7 +98,7 @@ export async function runCodexDefaultsSetup(options = {}) {
             path: plan.configPath,
             status: configState.exists ? 'updated' : 'created',
             detail: configState.exists
-                ? 'Updated CO baseline defaults additively and preserved unrelated keys.'
+                ? 'Updated CO-compatible baseline defaults and preserved unrelated keys.'
                 : 'Created config.toml with CO baseline defaults.'
         });
     }
@@ -87,9 +113,7 @@ export async function runCodexDefaultsSetup(options = {}) {
     }
     await mkdir(plan.agentsDir, { recursive: true });
     for (const roleChange of roleChanges) {
-        const shouldWrite = roleChange.existingContent === null
-            || (force && roleChange.existingContent !== roleChange.definition.content);
-        if (shouldWrite) {
+        if (roleChange.writeReason) {
             await writeAtomicFile(roleChange.path, roleChange.definition.content, {
                 ensureDir: true,
                 encoding: 'utf8'
@@ -99,9 +123,7 @@ export async function runCodexDefaultsSetup(options = {}) {
                 name: roleChange.definition.key,
                 path: roleChange.path,
                 status: roleChange.existingContent === null ? 'created' : 'updated',
-                detail: roleChange.existingContent === null
-                    ? `Created ${roleChange.definition.fileName}.`
-                    : `Overwrote ${roleChange.definition.fileName} because --force was set.`
+                detail: formatAppliedRoleWriteDetail(roleChange)
             });
             continue;
         }
@@ -126,6 +148,7 @@ export function formatCodexDefaultsSetupSummary(result) {
     lines.push(`- Config: ${result.plan.configPath}`);
     lines.push(`- Agents dir: ${result.plan.agentsDir}`);
     lines.push(`- Force overwrite: ${result.plan.force ? 'yes' : 'no'}`);
+    lines.push(`- Auth scope: ${result.plan.authScope}`);
     lines.push('- Changes:');
     for (const change of result.changes) {
         lines.push(`  - ${change.target}:${change.name} -> ${change.status} (${change.path})`);
@@ -136,13 +159,18 @@ export function formatCodexDefaultsSetupSummary(result) {
     }
     return lines;
 }
-function buildPlan(env, force) {
+function buildConfigPath(env) {
+    return join(resolveCodexHome(env), 'config.toml');
+}
+function buildPlan(env, force, authScope) {
+    const configPath = buildConfigPath(env);
     const codexHome = resolveCodexHome(env);
     return {
         codexHome,
-        configPath: join(codexHome, 'config.toml'),
+        configPath,
         agentsDir: join(codexHome, 'agents'),
-        force
+        force,
+        authScope
     };
 }
 async function loadConfigState(configPath) {
@@ -202,13 +230,19 @@ function canonicalizeConfigValue(value) {
     }
     return undefined;
 }
-function mergeBaselineDefaults(existing, roleDefinitions) {
+function mergeBaselineDefaults(existing, roleDefinitions, options) {
     const next = structuredClone(existing);
-    next.model = BASELINE_MODEL;
-    next.review_model = BASELINE_REVIEW_MODEL;
+    next.model = resolveModelDefault(options.topLevelLocalModelOptIn, BASELINE_MODEL);
+    next.review_model = resolveModelDefault(options.reviewModelOptIn, BASELINE_REVIEW_MODEL);
     next.model_reasoning_effort = BASELINE_REASONING;
+    removeLegacyLocalModelOptInMarker(next);
     const agents = isRecord(next.agents) ? structuredClone(next.agents) : {};
-    agents.max_threads = BASELINE_AGENTS.max_threads;
+    if (isMultiAgentV2Enabled(next, options.featureProbe)) {
+        delete agents.max_threads;
+    }
+    else {
+        agents.max_threads = BASELINE_AGENTS.max_threads;
+    }
     for (const role of roleDefinitions) {
         const existingRole = isRecord(agents[role.key])
             ? structuredClone(agents[role.key])
@@ -220,6 +254,71 @@ function mergeBaselineDefaults(existing, roleDefinitions) {
     next.agents = agents;
     return next;
 }
+export function isLocalModelOptIn(value) {
+    return typeof value === 'string' && LOCAL_MODEL_OPT_IN_SET.has(value);
+}
+export function resolveLocalModelOptIn(existing) {
+    const localConfig = isRecord(existing[CODEX_ORCHESTRATOR_CONFIG_KEY])
+        ? existing[CODEX_ORCHESTRATOR_CONFIG_KEY]
+        : null;
+    const configuredModel = localConfig?.[LOCAL_MODEL_OPT_IN_CONFIG_KEY];
+    return isLocalModelOptIn(configuredModel) ? configuredModel : null;
+}
+function resolveRequestedLocalModelOptIn(existing, requestedAuthScope) {
+    if (requestedAuthScope === 'portable') {
+        return null;
+    }
+    if (requestedAuthScope === 'chatgpt') {
+        return CURRENT_CHATGPT_MODEL;
+    }
+    const model = readOptionalString(existing.model);
+    const reviewModel = readOptionalString(existing.review_model);
+    if (isLocalModelOptIn(model)) {
+        return model;
+    }
+    if (isLocalModelOptIn(reviewModel)) {
+        return reviewModel;
+    }
+    return null;
+}
+function resolveRoleAndReviewLocalModelOptIn(existing, topLevelLocalModelOptIn, requestedAuthScope) {
+    if (requestedAuthScope === 'portable') {
+        return null;
+    }
+    if (topLevelLocalModelOptIn) {
+        return topLevelLocalModelOptIn;
+    }
+    const reviewModel = readOptionalString(existing.review_model);
+    const existingLocalModelOptIn = resolveLocalModelOptIn(existing);
+    return existingLocalModelOptIn === topLevelLocalModelOptIn
+        && reviewModel === topLevelLocalModelOptIn
+        && isLocalModelOptIn(reviewModel)
+        ? reviewModel
+        : null;
+}
+function readOptionalString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function removeLegacyLocalModelOptInMarker(next) {
+    const existingConfig = isRecord(next[CODEX_ORCHESTRATOR_CONFIG_KEY])
+        ? structuredClone(next[CODEX_ORCHESTRATOR_CONFIG_KEY])
+        : {};
+    if (LOCAL_MODEL_OPT_IN_CONFIG_KEY in existingConfig) {
+        delete existingConfig[LOCAL_MODEL_OPT_IN_CONFIG_KEY];
+        if (Object.keys(existingConfig).length > 0) {
+            next[CODEX_ORCHESTRATOR_CONFIG_KEY] = existingConfig;
+        }
+        else {
+            delete next[CODEX_ORCHESTRATOR_CONFIG_KEY];
+        }
+    }
+}
+export function formatModelDefaultExpectation(baseline) {
+    return `${CURRENT_CHATGPT_MODEL} when ChatGPT-auth access is verified (fallback: ${baseline})`;
+}
+function resolveModelDefault(localModelOptIn, baseline) {
+    return localModelOptIn ?? baseline;
+}
 async function planRoleChanges(agentsDir, force, roleDefinitions) {
     const changes = [];
     for (const definition of roleDefinitions) {
@@ -230,7 +329,8 @@ async function planRoleChanges(agentsDir, force, roleDefinitions) {
                 path,
                 existingContent: null,
                 currentStatus: 'pending',
-                detail: `Will create ${definition.fileName}.`
+                detail: `Will create ${definition.fileName}.`,
+                writeReason: 'create'
             });
             continue;
         }
@@ -241,7 +341,8 @@ async function planRoleChanges(agentsDir, force, roleDefinitions) {
                 path,
                 existingContent: current,
                 currentStatus: 'unchanged',
-                detail: `${definition.fileName} already matches CO baseline defaults.`
+                detail: `${definition.fileName} already matches CO baseline defaults.`,
+                writeReason: null
             });
             continue;
         }
@@ -251,7 +352,19 @@ async function planRoleChanges(agentsDir, force, roleDefinitions) {
                 path,
                 existingContent: current,
                 currentStatus: 'pending',
-                detail: `Will overwrite ${definition.fileName} because --force is set.`
+                detail: `Will overwrite ${definition.fileName} because --force is set.`,
+                writeReason: 'force'
+            });
+            continue;
+        }
+        if (definition.managedMigrationContents.includes(current)) {
+            changes.push({
+                definition,
+                path,
+                existingContent: current,
+                currentStatus: 'pending',
+                detail: `Will update ${definition.fileName} from a prior CO-managed model baseline.`,
+                writeReason: 'managed_migration'
             });
             continue;
         }
@@ -260,7 +373,8 @@ async function planRoleChanges(agentsDir, force, roleDefinitions) {
             path,
             existingContent: current,
             currentStatus: 'preserved',
-            detail: `${definition.fileName} already exists; preserving without --force.`
+            detail: `${definition.fileName} already exists; preserving without --force.`,
+            writeReason: null
         });
     }
     return changes;
@@ -278,10 +392,69 @@ async function loadRoleDefinitions() {
             const reason = error?.message ?? String(error);
             throw new Error(`Unable to read role template ${templateFile}: ${reason}`);
         }
-        loaded.push({ ...definition, content });
+        loaded.push({
+            ...definition,
+            content,
+            managedMigrationContents: buildManagedMigrationContents(content, definition)
+        });
     }
     return loaded;
 }
+function buildActiveRoleDefinitions(roleDefinitions, localModelOptIn) {
+    if (!localModelOptIn) {
+        return [...roleDefinitions];
+    }
+    return roleDefinitions.map((definition) => {
+        const matchingOptInBaseline = definition.managedMigrationBaselines?.find((baseline) => baseline.model === localModelOptIn);
+        if (!matchingOptInBaseline) {
+            return definition;
+        }
+        const optInContent = applyRoleBaselineOverrides(definition.content, definition.fileName, matchingOptInBaseline);
+        return {
+            ...definition,
+            content: optInContent,
+            managedMigrationContents: uniqueRoleContents([
+                definition.content,
+                ...definition.managedMigrationContents
+            ]).filter((migrationContent) => migrationContent !== optInContent)
+        };
+    });
+}
+function buildManagedMigrationContents(content, definition) {
+    const migrationContents = [
+        ...(definition.managedMigrationBaselines ?? []),
+        ...(definition.managedMigrationContentVariants ?? [])
+    ].map((baseline) => applyRoleBaselineOverrides(content, definition.fileName, baseline));
+    return uniqueRoleContents(migrationContents).filter((migrationContent) => migrationContent !== content);
+}
+function uniqueRoleContents(contents) {
+    return [...new Set(contents)];
+}
+function formatAppliedRoleWriteDetail(roleChange) {
+    switch (roleChange.writeReason) {
+        case 'create':
+            return `Created ${roleChange.definition.fileName}.`;
+        case 'force':
+            return `Overwrote ${roleChange.definition.fileName} because --force was set.`;
+        case 'managed_migration':
+            return `Updated ${roleChange.definition.fileName} from a prior CO-managed model baseline.`;
+        case null:
+            return roleChange.detail;
+    }
+}
+function applyRoleBaselineOverrides(content, fileName, baseline) {
+    let next = replaceRoleTomlString(content, 'model', baseline.model, fileName);
+    next = replaceRoleTomlString(next, 'model_reasoning_effort', baseline.modelReasoningEffort, fileName);
+    return next.replace(/^# with CO override to use .+ at .+ reasoning\.$/m, baseline.overrideComment
+        ?? `# with CO override to use ${baseline.model} at ${baseline.modelReasoningEffort} reasoning.`);
+}
+function replaceRoleTomlString(content, key, value, fileName) {
+    const pattern = new RegExp(`^(${key}\\s*=\\s*)"[^"]*"$`, 'm');
+    if (!pattern.test(content)) {
+        throw new Error(`Role template ${fileName} is missing a ${key} assignment.`);
+    }
+    return content.replace(pattern, (_match, prefix) => `${prefix}"${value}"`);
+}
 function buildPlannedChanges(params) {
     const changes = [];
     const configStatus = params.configChanged || !params.configExists ? 'pending' : 'unchanged';
@@ -292,7 +465,7 @@ function buildPlannedChanges(params) {
         status: configStatus,
         detail: configStatus === 'pending'
             ? params.configExists
-                ? 'Will update CO baseline defaults additively while preserving unrelated keys.'
+                ? 'Will update CO-compatible baseline defaults while preserving unrelated keys.'
                 : 'Will create config.toml with CO baseline defaults.'
             : 'CO baseline defaults already present.'
     });
@@ -310,3 +483,21 @@ function buildPlannedChanges(params) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
 }
+function isMultiAgentV2Enabled(config, featureProbe) {
+    if (featureProbe.flags?.multi_agent_v2 === true) {
+        return true;
+    }
+    if (codexFeatureProbeDisablesMultiAgentV2(featureProbe)) {
+        return false;
+    }
+    if (codexFeatureProbeRejectsAgentMaxThreads(featureProbe)) {
+        return true;
+    }
+    if (!isRecord(config.features)) {
+        return false;
+    }
+    return readBooleanValue(config.features.multi_agent_v2) === true;
+}
+function readBooleanValue(value) {
+    return typeof value === 'boolean' ? value : null;
+}

package/dist/orchestrator/src/cli/control/controlHostSupervision.js

@@ -315,14 +315,12 @@ export function evaluateControlHostSupervisionProbeTimeoutDiagnostic(diagnostic,
     if (!diagnostic || diagnostic.running_workers.length === 0) {
         return null;
     }
-    if (!isProviderRefreshLifecycleRestartRequiredDiagnostic(diagnostic.polling)) {
-        return null;
-    }
     if (!isCurrentControlHostSupervisionPollingDiagnostic(diagnostic.polling, options.minPollingUpdatedAt)) {
         return null;
     }
-    const pollingReason = diagnostic.polling?.reason ?? diagnostic.polling?.last_error ?? null;
-    if (!pollingReason) {
+    const restartRequired = isProviderRefreshLifecycleRestartRequiredDiagnostic(diagnostic.polling);
+    const activeRefresh = isActiveProviderRefreshProbeTimeoutDiagnostic(diagnostic.polling);
+    if (!restartRequired && !activeRefresh) {
         return null;
     }
     if (hasAvailableProviderWorkerCapacity(diagnostic)) {
@@ -371,6 +369,18 @@ function isProviderRefreshLifecycleRestartRequiredDiagnostic(polling) {
     return (polling.reason === 'provider_refresh_lifecycle_stuck' ||
         polling.last_error === 'provider_refresh_lifecycle_stuck');
 }
+function isActiveProviderRefreshProbeTimeoutDiagnostic(polling) {
+    if (!polling || polling.checking !== true) {
+        return false;
+    }
+    if (polling.restart_required === true || polling.stuck === true) {
+        return false;
+    }
+    if (polling.reason !== null) {
+        return false;
+    }
+    return polling.refresh_phase?.startsWith('refresh:') === true;
+}
 function isCurrentControlHostSupervisionPollingDiagnostic(polling, minPollingUpdatedAt) {
     const minimumUpdatedAt = parseIsoTimestampToMs(minPollingUpdatedAt);
     if (minimumUpdatedAt === null) {
@@ -467,10 +477,22 @@ function buildControlHostSupervisionRestartSignature(diagnostic) {
     // Quarantine repeated restart churn on the stable active-worker series, not on transient
     // refresh checkpoints that can legitimately drift within one stuck refresh cycle.
     return JSON.stringify({
-        reason: diagnostic.polling.reason ?? diagnostic.polling.last_error ?? null,
+        reason: buildControlHostSupervisionRestartReasonKey(diagnostic.polling),
         worker_series: workerSeries
     });
 }
+function buildControlHostSupervisionRestartReasonKey(polling) {
+    if (polling.reason) {
+        return polling.reason;
+    }
+    if (isActiveProviderRefreshProbeTimeoutDiagnostic(polling)) {
+        return 'active_provider_refresh_probe_timeout';
+    }
+    if (isProviderRefreshLifecycleRestartRequiredDiagnostic(polling)) {
+        return 'provider_refresh_lifecycle_stuck';
+    }
+    return polling.last_error ?? null;
+}
 function buildControlHostSupervisionWorkerSeriesKey(worker) {
     if (worker.issue_identifier.length === 0) {
         return null;

package/dist/orchestrator/src/cli/control/controlRuntime.js

@@ -883,6 +883,8 @@ function buildCompatibilityTelemetrySnapshot(sources, polling) {
     let hasOutputTokens = false;
     let totalTokens = 0;
     let hasTotalTokens = false;
+    let reasoningOutputTokens = 0;
+    let hasReasoningOutputTokens = false;
     let secondsRunning = 0;
     let latestAuthoritativeRateLimits = polling?.linear_budget
         ? { ...polling.linear_budget }
@@ -908,6 +910,11 @@ function buildCompatibilityTelemetrySnapshot(sources, polling) {
             totalTokens += Math.max(0, tokenUsage.total_tokens);
             hasTotalTokens = true;
         }
+        if (typeof tokenUsage?.reasoning_output_tokens === 'number' &&
+            Number.isFinite(tokenUsage.reasoning_output_tokens)) {
+            reasoningOutputTokens += Math.max(0, tokenUsage.reasoning_output_tokens);
+            hasReasoningOutputTokens = true;
+        }
         secondsRunning += computeCompatibilityRuntimeSeconds(source, now);
         const linearBudget = proof?.linear_budget ? { ...proof.linear_budget } : null;
         if (linearBudget) {
@@ -926,13 +933,17 @@ function buildCompatibilityTelemetrySnapshot(sources, polling) {
             }
         }
     }
+    const codexTotals = {
+        input_tokens: hasInputTokens ? inputTokens : null,
+        output_tokens: hasOutputTokens ? outputTokens : null,
+        total_tokens: hasTotalTokens ? totalTokens : null,
+        seconds_running: Number(secondsRunning.toFixed(3))
+    };
+    if (hasReasoningOutputTokens) {
+        codexTotals.reasoning_output_tokens = reasoningOutputTokens;
+    }
     return {
-        codexTotals: {
-            input_tokens: hasInputTokens ? inputTokens : null,
-            output_tokens: hasOutputTokens ? outputTokens : null,
-            total_tokens: hasTotalTokens ? totalTokens : null,
-            seconds_running: Number(secondsRunning.toFixed(3))
-        },
+        codexTotals,
         rateLimits: combineCompatibilityRateLimits({
             codex: latestCodexRateLimits,
             linearBudget: latestAuthoritativeRateLimits

package/dist/orchestrator/src/cli/control/controlStatusDashboard.js

@@ -738,7 +738,12 @@ function renderTokensLine(dataset, terminalColumns) {
         { text: ' | ', color: ANSI_GRAY },
         { text: `out ${formatOptionalCount(dataset.totals.output_tokens)}`, color: ANSI_YELLOW },
         { text: ' | ', color: ANSI_GRAY },
-        { text: `total ${formatOptionalCount(dataset.totals.total_tokens)}`, color: ANSI_YELLOW }
+        { text: `total ${formatOptionalCount(dataset.totals.total_tokens)}`, color: ANSI_YELLOW },
+        { text: ' | ', color: ANSI_GRAY },
+        {
+            text: `reasoning ${formatOptionalCount(dataset.totals.reasoning_output_tokens)}`,
+            color: ANSI_YELLOW
+        }
     ], terminalColumns);
 }
 function renderRateLimitsLine(dataset, referenceTime, terminalColumns) {

package/dist/orchestrator/src/cli/control/selectedRunProjection.js

@@ -1370,11 +1370,58 @@ function hasProviderLinearWorkerProjectionRetiredChildLaneResidue(proof) {
 }
 function hasProviderLinearWorkerProjectionTelemetryGap(proof) {
     const tokens = proof.tokens ?? null;
-    const hasTokens = tokens?.input_tokens != null || tokens?.output_tokens != null || tokens?.total_tokens != null;
+    const hasTokens = tokens?.input_tokens != null ||
+        tokens?.output_tokens != null ||
+        tokens?.total_tokens != null ||
+        tokens?.reasoning_output_tokens != null;
     return (!proof.latest_turn_id ||
         !proof.latest_session_id ||
         !hasTokens ||
-        proof.rate_limits == null);
+        proof.rate_limits == null ||
+        hasProviderLinearWorkerProjectionSessionLogHydrationGap(proof) ||
+        hasProviderLinearWorkerProjectionAppServerSupervisionGap(proof));
+}
+function hasProviderLinearWorkerProjectionAppServerSupervisionGap(proof) {
+    const selectedRuntimeMode = proof.runtime?.selected_mode ?? proof.auth_provenance?.runtime_mode ?? null;
+    const requestedRuntimeMode = proof.runtime?.requested_mode ?? null;
+    const fallback = proof.runtime?.fallback ?? null;
+    if (selectedRuntimeMode !== 'appserver' &&
+        requestedRuntimeMode !== 'appserver' &&
+        fallback?.from_mode !== 'appserver' &&
+        fallback?.to_mode !== 'appserver') {
+        return false;
+    }
+    const supervision = proof.appserver_supervision ?? null;
+    if (!supervision) {
+        return true;
+    }
+    const expectedSessionLogTruthRetained = selectedRuntimeMode === 'appserver';
+    return (supervision.selected_runtime?.selected_mode !== selectedRuntimeMode ||
+        supervision.selected_runtime?.requested_mode !== requestedRuntimeMode ||
+        supervision.thread_id !== proof.thread_id ||
+        supervision.latest_turn_id !== proof.latest_turn_id ||
+        supervision.latest_session_id !== proof.latest_session_id ||
+        supervision.session_log_thread_id !== (proof.session_log_thread_id ?? null) ||
+        supervision.session_log_turn_id !== (proof.session_log_turn_id ?? null) ||
+        supervision.session_log_session_id !== (proof.session_log_session_id ?? null) ||
+        supervision.turn_persistence_status == null ||
+        supervision.pagination_status == null ||
+        supervision.resume_status == null ||
+        supervision.fork_status == null ||
+        supervision.jsonl_truth_retained !== true ||
+        supervision.session_log_truth_retained !== expectedSessionLogTruthRetained);
+}
+function hasProviderLinearWorkerProjectionSessionLogHydrationGap(proof) {
+    const runtimeMode = proof.runtime?.selected_mode ?? proof.auth_provenance?.runtime_mode ?? null;
+    if (runtimeMode !== 'appserver') {
+        return false;
+    }
+    if (!proof.thread_id || !proof.latest_turn_id || !proof.latest_session_id) {
+        return false;
+    }
+    return (proof.session_log_thread_id !== proof.thread_id ||
+        proof.session_log_turn_id !== proof.latest_turn_id ||
+        proof.session_log_session_id !== proof.latest_session_id);
 }
 function canSkipProviderLinearWorkerProjectionSessionLogHydration(proof, telemetryGap) {
     if (proof.owner_phase !== 'turn_completed') {