sneakoscope 8.1.2 → 8.2.0

package/dist/core/retention.js

@@ -1,9 +1,9 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
-import { randomUUID } from 'node:crypto';
-import { exists, readJson, writeJsonAtomic, ensureDir, dirSize, fileSize, formatBytes, rmrf, nowIso, appendJsonlBounded, listFilesRecursive, managedSksTmpRoot, sha256, SKS_TEMP_LEASE_FILE } from './fsx.js';
+import { exists, readJson, writeJsonAtomic, ensureDir, dirSize, fileSize, formatBytes, rmrf, nowIso, appendJsonlBounded, listFilesRecursive, managedSksTmpRoot, sha256 } from './fsx.js';
 import { FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS } from './routes.js';
+import { activeTempEnvironmentKey, currentProcessOwns, inspectTempPath, liveTempLease, removeDeadCanonicalTestLease, sharedTempEntryMatchesProject } from './retention/temp-lease.js';
 export const DEFAULT_RETENTION_POLICY = Object.freeze({
     schema_version: 1,
     max_missions: 30,
@@ -107,8 +107,6 @@ const FULL_RETENTION_SCAN_MAX_FILES = 1_000_000;
 const FULL_RETENTION_SCAN_MAX_DEPTH = 80;
 const MISSION_COMPACTION_SCAN_MAX_FILES = 100_000;
 const MISSION_COMPACTION_SCAN_MAX_DEPTH = 20;
-const TEMP_RETENTION_SCAN_MAX_ENTRIES = 100_000;
-const TEMP_RETENTION_SCAN_MAX_DEPTH = 20;
 export async function ensureRetentionPolicy(root) {
     const p = path.join(root, '.sneakoscope', 'policy.json');
     if (!(await exists(p)))
@@ -414,197 +412,6 @@ async function safeMissionDirectory(root, id) {
         return null;
     return candidate;
 }
-async function inspectTempPath(target) {
-    const rootStat = await fs.lstat(target).catch(() => null);
-    if (!rootStat || rootStat.isSymbolicLink()) {
-        return {
-            complete: false,
-            latestMtimeMs: 0,
-            bytes: 0,
-            blockers: [rootStat ? 'temp_path_is_symlink' : 'temp_path_missing_or_unreadable']
-        };
-    }
-    let latestMtimeMs = rootStat.mtimeMs;
-    let bytes = rootStat.isFile() ? rootStat.size : 0;
-    let entryCount = 0;
-    const blockers = [];
-    const stack = rootStat.isDirectory()
-        ? [{ dir: target, depth: 0 }]
-        : [];
-    while (stack.length) {
-        const current = stack.pop();
-        let entries;
-        try {
-            entries = await fs.readdir(current.dir, { withFileTypes: true });
-        }
-        catch {
-            blockers.push('temp_path_readdir_failed');
-            continue;
-        }
-        for (const entry of entries) {
-            entryCount += 1;
-            if (entryCount > TEMP_RETENTION_SCAN_MAX_ENTRIES) {
-                blockers.push(`temp_path_max_entries_exceeded:${TEMP_RETENTION_SCAN_MAX_ENTRIES}`);
-                return { complete: false, latestMtimeMs, bytes, blockers: [...new Set(blockers)] };
-            }
-            const child = path.join(current.dir, entry.name);
-            const stat = await fs.lstat(child).catch(() => null);
-            if (!stat) {
-                blockers.push('temp_path_stat_failed');
-                continue;
-            }
-            latestMtimeMs = Math.max(latestMtimeMs, stat.mtimeMs);
-            if (stat.isSymbolicLink())
-                continue;
-            if (stat.isDirectory()) {
-                if (current.depth >= TEMP_RETENTION_SCAN_MAX_DEPTH) {
-                    blockers.push(`temp_path_max_depth_exceeded:${TEMP_RETENTION_SCAN_MAX_DEPTH}`);
-                }
-                else {
-                    stack.push({ dir: child, depth: current.depth + 1 });
-                }
-                continue;
-            }
-            if (stat.isFile())
-                bytes += stat.size;
-        }
-    }
-    return {
-        complete: blockers.length === 0,
-        latestMtimeMs,
-        bytes,
-        blockers: [...new Set(blockers)]
-    };
-}
-function currentProcessOwns(stat) {
-    if (typeof process.getuid !== 'function')
-        return true;
-    return stat.uid === process.getuid();
-}
-function sharedTempEntryMatchesProject(entryName, projectHash) {
-    return entryName === `sks-${projectHash}` || entryName.startsWith(`sks-${projectHash}-`);
-}
-function activeTempEnvironmentKey(target) {
-    const resolvedTarget = path.resolve(target);
-    for (const key of ['SKS_TMP_DIR', 'TMPDIR', 'TMP', 'TEMP']) {
-        const raw = process.env[key];
-        if (!raw)
-            continue;
-        const activePath = path.resolve(raw);
-        if (isWithin(resolvedTarget, activePath))
-            return key;
-    }
-    return null;
-}
-async function liveTempLease(target) {
-    const leasePath = path.join(target, SKS_TEMP_LEASE_FILE);
-    const stat = await fs.lstat(leasePath).catch(() => null);
-    if (!stat?.isFile() || stat.isSymbolicLink() || !currentProcessOwns(stat))
-        return null;
-    const lease = await readJson(leasePath, null).catch(() => null);
-    const pid = Number(lease?.pid);
-    if (lease?.schema !== 'sks.temp-lease.v1' || !processIdAlive(pid))
-        return null;
-    return {
-        path: leasePath,
-        pid,
-        kind: lease?.kind ? String(lease.kind) : null
-    };
-}
-async function removeDeadCanonicalTestLease(base, target, targetStat, dryRun, actions) {
-    if (!targetStat.isDirectory() || targetStat.isSymbolicLink() || !currentProcessOwns(targetStat))
-        return false;
-    const [realBase, realTarget] = await Promise.all([
-        fs.realpath(base).catch(() => null),
-        fs.realpath(target).catch(() => null)
-    ]);
-    if (!realBase || !realTarget || path.dirname(realTarget) !== realBase || !isWithin(realBase, realTarget))
-        return false;
-    const leasePath = path.join(target, SKS_TEMP_LEASE_FILE);
-    const leaseLstat = await fs.lstat(leasePath).catch(() => null);
-    if (!leaseLstat?.isFile() || leaseLstat.isSymbolicLink() || !currentProcessOwns(leaseLstat) || leaseLstat.size > 4096)
-        return false;
-    const leaseHandle = await fs.open(leasePath, 'r').catch(() => null);
-    if (!leaseHandle)
-        return false;
-    let lease = null;
-    try {
-        const leaseStat = await leaseHandle.stat();
-        if (!leaseStat.isFile()
-            || !currentProcessOwns(leaseStat)
-            || leaseStat.dev !== leaseLstat.dev
-            || leaseStat.ino !== leaseLstat.ino)
-            return false;
-        lease = JSON.parse(await leaseHandle.readFile({ encoding: 'utf8' }));
-    }
-    catch {
-        return false;
-    }
-    finally {
-        await leaseHandle.close().catch(() => undefined);
-    }
-    const leaseKeys = lease && typeof lease === 'object' && !Array.isArray(lease)
-        ? Object.keys(lease).sort()
-        : [];
-    const pid = Number(lease?.pid);
-    if (lease?.schema !== 'sks.temp-lease.v1'
-        || lease?.kind !== 'canonical-test-runner'
-        || !Number.isSafeInteger(pid)
-        || pid <= 0
-        || typeof lease?.created_at !== 'string'
-        || !Number.isFinite(Date.parse(lease.created_at))
-        || leaseKeys.join(',') !== 'created_at,kind,pid,schema'
-        || processIdAlive(pid))
-        return false;
-    const currentTargetStat = await fs.lstat(target).catch(() => null);
-    if (!currentTargetStat?.isDirectory()
-        || currentTargetStat.isSymbolicLink()
-        || !currentProcessOwns(currentTargetStat)
-        || currentTargetStat.dev !== targetStat.dev
-        || currentTargetStat.ino !== targetStat.ino)
-        return false;
-    const action = {
-        action: 'remove_sks_temp',
-        path: target,
-        reason: 'dead_canonical_test_lease',
-        lease_path: leasePath,
-        owner_pid: pid,
-        lease_kind: lease.kind
-    };
-    if (dryRun) {
-        actions.push(action);
-        return true;
-    }
-    const quarantine = path.join(realBase, `.sks-retention-quarantine-${process.pid}-${randomUUID()}`);
-    try {
-        await fs.rename(target, quarantine);
-    }
-    catch {
-        return false;
-    }
-    const quarantinedStat = await fs.lstat(quarantine).catch(() => null);
-    if (!quarantinedStat
-        || quarantinedStat.dev !== targetStat.dev
-        || quarantinedStat.ino !== targetStat.ino) {
-        if (!(await exists(target)))
-            await fs.rename(quarantine, target).catch(() => undefined);
-        return false;
-    }
-    await rmrf(quarantine);
-    actions.push(action);
-    return true;
-}
-function processIdAlive(pid) {
-    if (!Number.isSafeInteger(pid) || pid <= 0)
-        return false;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        return error?.code === 'EPERM';
-    }
-}
 async function pruneTmp(root, policy, dryRun, actions) {
     const tmp = path.join(root, '.sneakoscope', 'tmp');
     if (!(await exists(tmp)))
@@ -1251,6 +1058,8 @@ export async function sweepSksTempDirs(root, opts = {}) {
     const maxAgeMs = Math.max(0, Number(opts.maxAgeHours ?? 6)) * 60 * 60 * 1000;
     const realRoot = await fs.realpath(path.resolve(root)).catch(() => path.resolve(root));
     const projectHash = sha256(realRoot).slice(0, 12);
+    const activeTempRoot = path.resolve(os.tmpdir());
+    const activeTempRootLease = await liveTempLease(activeTempRoot);
     const roots = [
         { base: path.join(os.tmpdir(), 'sks-gate'), external: true, shared: true },
         { base: managedSksTmpRoot(), external: true, shared: false, canonicalLeaseCleanup: true },
@@ -1264,6 +1073,20 @@ export async function sweepSksTempDirs(root, opts = {}) {
         const base = rootSpec.base;
         if (!(await exists(base)))
             continue;
+        if (rootSpec.external
+            && activeTempRootLease
+            && activeTempRootLease.kind === 'canonical-test-runner'
+            && isWithin(activeTempRoot, base)) {
+            actions.push({
+                action: 'skip_sks_temp_sweep',
+                path: base,
+                reason: 'active_parent_temp_lease',
+                lease_path: activeTempRootLease.path,
+                owner_pid: activeTempRootLease.pid,
+                lease_kind: activeTempRootLease.kind
+            });
+            continue;
+        }
         if (!(await safeRetentionBase(root, base, { external: rootSpec.external }))) {
             actions.push({ action: 'skip_unsafe_retention_root', path: base, reason: 'symlink_or_outside_managed_temp' });
             continue;

package/dist/core/routes.js

@@ -661,10 +661,9 @@ export const COMMAND_CATALOG = [
     { name: 'uninstall', usage: 'sks uninstall [--dry-run] [--yes] [--keep-config] [--keep-data] [--purge-projects] [--json]', description: 'Remove SKS global skills, hooks, menu bar, state, temp files, and optional project residue while preserving user-owned content by default.' },
     { name: 'deps', usage: 'sks deps check [--json] [--yes]', description: 'Check Node/npm and Codex CLI readiness; pass --yes to repair missing Codex CLI tooling when supported.' },
     { name: 'codex', usage: 'sks codex compatibility|version|update-status [--refresh]|update|doctor|schema|current [--json]', description: 'Check Codex CLI compatibility/version/update status, run the official `codex update`, and inspect current manifest, capability, and hook-schema evidence.' },
-    { name: 'codex-app', usage: 'sks codex-app [check|set-openrouter-key --api-key-stdin|use-openrouter --model <id>|openrouter-status|product-design|chrome-extension|pat status|remote-control]', description: 'Check Codex App install, OpenRouter provider activation, codex-lb key-entry guidance, Product Design plugin readiness, Codex Chrome Extension web verification readiness, PAT-safe status, first-party MCP/plugin readiness, and Codex CLI remote-control availability.' },
+    { name: 'codex-app', usage: 'sks codex-app [check|status|restart|product-design|chrome-extension|pat status|remote-control]', description: 'Check Codex App integration, Desktop Bridge readiness, Product Design plugin readiness, Codex Chrome Extension web verification readiness, PAT-safe status, first-party MCP/plugin readiness, and Codex CLI remote-control availability. Provider routing is managed only by sks bridge.' },
     { name: 'codex-native', usage: 'sks codex-native status|feature-broker|invocation-plan|init-deep [--json]', description: 'Inspect Codex Native feature broker readiness, invocation routing, pattern evidence, and managed memory setup.' },
     { name: 'hooks', usage: 'sks hooks explain|status|trust-report|replay|codex-validate|warning-check ... [--json]', description: 'Explain Codex hook events, validate current vendored event output schemas, replay fixtures, and enforce warning-zero SKS hook policies.' },
-    { name: 'codex-lb', usage: 'sks codex-lb status|connect-test|health|metrics|doctor|circuit|repair|setup ...', description: 'Configure, run a one-request connection proof, health-check, repair, and record circuit evidence for codex-lb provider auth without confusing ChatGPT OAuth and proxy keys.' },
     { name: 'remote', usage: 'sks remote readiness|machines|worker ... [--json]', description: 'Inspect official Codex Remote readiness and the allowlisted proof-aware SSH stdio worker surface.' },
     { name: 'mad-sks', usage: 'sks mad-sks plan|run|apply|sql|apply-migration|status|close|rollback-apply ... | sks --mad [--high]', description: 'Open or inspect MAD-SKS scoped permission workflows, merged SQL-plane execution, and the native Codex permission launcher.' },
     { name: 'auto-review', usage: 'sks auto-review status|enable|start [--high] | sks --Auto-review --high', description: 'Enable Codex automatic approval review and launch the native Codex session with the auto-review profile.' },

package/dist/core/safety/intent-contract/intent-contract.js

@@ -18,7 +18,7 @@ export function buildIntentContract(input) {
         canonical_command: normalizeCommand(input.canonicalCommand),
         target_hashes: [...new Set(input.targetHashes)].sort(),
         policy_version: safeIdentifier(input.policyVersion, 'intent_policy_version_invalid'),
-        mode_snapshot: input.modeSnapshot,
+        runtime_snapshot: input.runtimeSnapshot,
         evidence_state: input.evidenceState,
         retry_budget: Math.max(0, Math.min(2, input.retryBudget ?? 0)),
         risk,
@@ -34,8 +34,8 @@ export function decideIntentReplay(previous, current) {
     const reasons = [];
     if (previous.policy_version !== current.policy_version)
         reasons.push('policy_version_changed');
-    if (previous.mode_snapshot !== current.mode_snapshot)
-        reasons.push('mode_snapshot_changed');
+    if (previous.runtime_snapshot !== current.runtime_snapshot)
+        reasons.push('runtime_snapshot_changed');
     if (JSON.stringify(previous.target_hashes) !== JSON.stringify(current.target_hashes))
         reasons.push('target_hash_changed');
     if (previous.effect !== current.effect || previous.canonical_command !== current.canonical_command)

package/dist/core/subagents/naruto-host-credentials.js

@@ -1,6 +1,7 @@
 import { LUNA_SUBAGENT_MODEL, SOL_SUBAGENT_MODEL, TERRA_SUBAGENT_MODEL } from './model-policy.js';
 export const NARUTO_AUTH_MODES = ['managed', 'host'];
 const IDENTIFIER_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+const RETIRED_DIRECT_MANAGED_PROVIDERS = new Set(['codex-lb', 'openrouter']);
 export const NARUTO_EFFORT_TIERS = ['minimal', 'low', 'medium', 'high', 'max'];
 function readFlagValue(args, name) {
     const inline = args.find((arg) => arg.startsWith(`${name}=`));
@@ -55,6 +56,9 @@ export function resolveNarutoCredentialPolicy(input) {
         else if (authMode === 'managed') {
             blockers.push('naruto_model_provider_requires_host_auth_mode');
         }
+        else if (RETIRED_DIRECT_MANAGED_PROVIDERS.has(providerRaw.value)) {
+            blockers.push('desktop_bridge_direct_provider_selection_retired');
+        }
         else {
             modelProvider = providerRaw.value;
             sources.modelProvider = providerRaw.source;
@@ -149,8 +153,9 @@ function validateGpt56EffortPair(scope, model, effort, blockers) {
 }
 export function narutoCredentialConfigArgs(policy) {
     const out = [];
-    if (policy.modelProvider)
+    if (policy.modelProvider && !RETIRED_DIRECT_MANAGED_PROVIDERS.has(policy.modelProvider)) {
         out.push('-c', `model_provider="${policy.modelProvider}"`);
+    }
     if (policy.forcedLoginMethod)
         out.push('-c', `forced_login_method="${policy.forcedLoginMethod}"`);
     return out;

package/dist/core/subagents/official-subagent-config.js

@@ -124,9 +124,14 @@ export async function readOfficialSubagentConfig(root, opts = {}) {
     const defaultSubagentModel = resolveLayeredValue(projectLayer.agents.default_subagent_model, globalLayer.agents.default_subagent_model, DEFAULT_OFFICIAL_SUBAGENT_MODEL, nonEmptyString);
     const defaultSubagentReasoningEffort = resolveLayeredValue(projectLayer.agents.default_subagent_reasoning_effort, globalLayer.agents.default_subagent_reasoning_effort, DEFAULT_OFFICIAL_SUBAGENT_REASONING_EFFORT, nonEmptyString);
     const multiAgentV2 = resolveMultiAgentV2Layer(projectLayer.features.multi_agent_v2, globalLayer.features.multi_agent_v2, effectiveMaxThreads);
+    const effectiveMultiAgentV2 = {
+        ...multiAgentV2.value,
+        maxConcurrentThreadsPerSession: Math.min(multiAgentV2.value.maxConcurrentThreadsPerSession, HARD_NARUTO_MAX_THREADS + 1)
+    };
     const depthCoerced = maxDepth.value > 1;
     const warnings = [
         ...(depthCoerced ? [`official_subagent_max_depth_coerced_to_one:${maxDepth.value}:${maxDepth.source}`] : []),
+        ...capacityNormalizationWarnings(maxThreads, multiAgentV2),
         ...(projectLayer.legacyWarnings),
         ...(globalLayer.legacyWarnings)
     ];
@@ -138,7 +143,7 @@ export async function readOfficialSubagentConfig(root, opts = {}) {
         interruptMessage: interruptMessage.value,
         defaultSubagentModel: defaultSubagentModel.value,
         defaultSubagentReasoningEffort: defaultSubagentReasoningEffort.value,
-        multiAgentV2: multiAgentV2.value,
+        multiAgentV2: effectiveMultiAgentV2,
         sources: {
             enabled: enabled.source,
             maxThreads: maxThreads.source,
@@ -159,11 +164,15 @@ export function officialSubagentConfigWarnings(text = '', inheritedText = '') {
     const inherited = configLayer(inheritedText, 'global');
     if (project.blockers.length || inherited.blockers.length)
         return [];
+    const maxThreads = resolveLayeredValue(readAgentsMaxThreadsFromRecord(project.agents), readAgentsMaxThreadsFromRecord(inherited.agents), DEFAULT_OFFICIAL_SUBAGENT_MAX_THREADS, positiveInteger);
+    const effectiveMaxThreads = Math.min(maxThreads.value, HARD_NARUTO_MAX_THREADS);
+    const multiAgentV2 = resolveMultiAgentV2Layer(project.features.multi_agent_v2, inherited.features.multi_agent_v2, effectiveMaxThreads);
     const maxDepth = resolveLayeredValue(project.agents.max_depth, inherited.agents.max_depth, DEFAULT_OFFICIAL_SUBAGENT_MAX_DEPTH, positiveInteger);
     return [
         ...(maxDepth.value > 1
             ? [`official_subagent_max_depth_coerced_to_one:${maxDepth.value}:${maxDepth.source}`]
             : []),
+        ...capacityNormalizationWarnings(maxThreads, multiAgentV2),
         ...project.legacyWarnings,
         ...inherited.legacyWarnings
     ];
@@ -364,16 +373,8 @@ function configLayer(text, label) {
             ...(configuredMaxThreads !== undefined && positiveInteger(configuredMaxThreads) === null
                 ? [`${label}_official_subagent_max_threads_invalid`]
                 : []),
-            ...(positiveInteger(configuredMaxThreads) !== null
-                && Number(configuredMaxThreads) > HARD_NARUTO_MAX_THREADS
-                ? [`${label}_official_subagent_max_threads_exceeds_hard_cap:${configuredMaxThreads}:${HARD_NARUTO_MAX_THREADS}`]
-                : []),
             ...(configuredV2Threads !== undefined && positiveInteger(configuredV2Threads) === null
                 ? [`${label}_official_subagent_multi_agent_v2_max_threads_invalid`]
-                : []),
-            ...(positiveInteger(configuredV2Threads) !== null
-                && Number(configuredV2Threads) > HARD_NARUTO_MAX_THREADS + 1
-                ? [`${label}_official_subagent_multi_agent_v2_max_threads_exceeds_hard_cap:${configuredV2Threads}:${HARD_NARUTO_MAX_THREADS + 1}`]
                 : [])
         ],
         legacyWarnings
@@ -393,6 +394,23 @@ function resolveMultiAgentV2Layer(projectValue, globalValue, maxThreads) {
         return { value: global, source: 'global' };
     return { value: fallback, source: 'default' };
 }
+function capacityNormalizationWarnings(maxThreads, multiAgentV2) {
+    return [
+        ...(maxThreads.value > HARD_NARUTO_MAX_THREADS
+            ? [
+                `official_subagent_max_threads_normalized:configured=${maxThreads.value}`
+                    + `:effective=${HARD_NARUTO_MAX_THREADS}:source=${maxThreads.source}`
+            ]
+            : []),
+        ...(multiAgentV2.value.maxConcurrentThreadsPerSession > HARD_NARUTO_MAX_THREADS + 1
+            ? [
+                'official_subagent_multi_agent_v2_max_threads_normalized'
+                    + `:configured=${multiAgentV2.value.maxConcurrentThreadsPerSession}`
+                    + `:effective=${HARD_NARUTO_MAX_THREADS + 1}:source=${multiAgentV2.source}`
+            ]
+            : [])
+    ];
+}
 function normalizeMultiAgentV2(value, fallback) {
     if (value === true) {
         return { ...fallback, enabled: true };

package/dist/core/subagents/official-subagent-runner.js

@@ -3,7 +3,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { randomId, runProcess, writeJsonAtomic } from '../fsx.js';
 import { DEFAULT_SUBAGENT_EFFORT, DEFAULT_SUBAGENT_MODEL, NARUTO_PARENT_EFFORT, NARUTO_PARENT_MODEL } from './model-policy.js';
-import { inspectCodexLbCliLaunchRecovery } from '../codex-control/codex-lb-launch-recovery.js';
+import { inspectDesktopBridgeCliLaunchGuard, stripRetiredDirectProviderEnv } from '../codex-control/desktop-bridge-launch-guard.js';
 import { prepareCodexAppServerRuntimeEnv } from '../codex-control/codex-app-server-runtime-env.js';
 import { probeNarutoCodexCapability } from '../codex-compat/codex-capability-matrix.js';
 import { resolveOfficialCodexPackageRuntime } from '../codex-runtime/resolve-codex-runtime.js';
@@ -359,27 +359,12 @@ export async function runOfficialSubagentWorkflow(input) {
         hostCapabilityLaunchNonce = randomId(32);
         hostCapabilityPendingDir = officialSubagentMissionDir(canonicalRoot, input.missionId);
     }
-    const sourceEnv = { ...process.env, ...(input.env || {}) };
-    const runtimeEnv = input.credentialPolicy?.authMode === 'managed'
+    const sourceEnv = stripRetiredDirectProviderEnv({ ...process.env, ...(input.env || {}) });
+    const preparedRuntimeEnv = input.credentialPolicy?.authMode === 'managed'
         ? sourceEnv
         : await (input.prepareCodexRuntimeEnvImpl || prepareCodexAppServerRuntimeEnv)({ env: sourceEnv });
-    const codexLbCliSelected = Boolean(runtimeEnv.CODEX_LB_API_KEY && runtimeEnv.CODEX_LB_BASE_URL);
-    const resolvedCredentialPolicy = input.credentialPolicy ?? (codexLbCliSelected
-        ? resolveNarutoCredentialPolicy({
-            args: ['--auth-mode=host', '--model-provider=codex-lb', '--provider-env-key=CODEX_LB_API_KEY'],
-            env: runtimeEnv,
-            defaultParentModel: NARUTO_PARENT_MODEL,
-            defaultParentEffort: NARUTO_PARENT_EFFORT,
-            defaultSubagentModel: DEFAULT_SUBAGENT_MODEL,
-            defaultSubagentEffort: DEFAULT_SUBAGENT_EFFORT
-        })
-        : defaultNarutoCredentialPolicy());
-    const credentialPolicy = codexLbCliSelected
-        && resolvedCredentialPolicy.authMode === 'host'
-        && resolvedCredentialPolicy.modelProvider === null
-        && resolvedCredentialPolicy.providerEnvKey === null
-        ? { ...resolvedCredentialPolicy, providerEnvKey: 'CODEX_LB_API_KEY' }
-        : resolvedCredentialPolicy;
+    const runtimeEnv = stripRetiredDirectProviderEnv(preparedRuntimeEnv);
+    const credentialPolicy = input.credentialPolicy ?? defaultNarutoCredentialPolicy();
     const inheritedSecretValues = knownInheritedSecretValues(runtimeEnv);
     const childEnv = buildOfficialSubagentChildEnv({
         env: runtimeEnv,
@@ -492,27 +477,25 @@ export async function runOfficialSubagentWorkflow(input) {
         hostCapabilityConfigArgs: hostCapabilityCodexConfigArgs(hostCapabilityRuntime),
         credentialPolicy
     });
-    const toolOutputRecovery = await inspectCodexLbCliLaunchRecovery({
+    const launchGuard = await inspectDesktopBridgeCliLaunchGuard({
         root: input.root,
         env: childEnv,
-        cliArgs: args.slice(0, -1),
-        ...(input.recoveryFetch ? { fetchImpl: input.recoveryFetch } : {}),
-        ...(input.recoveryTimeoutMs === undefined ? {} : { timeoutMs: input.recoveryTimeoutMs })
+        cliArgs: args.slice(0, -1)
     });
-    if (!toolOutputRecovery.ok) {
+    if (!launchGuard.ok) {
         return {
             ...base,
             ok: false,
-            status: 'tool_output_recovery_blocked',
+            status: 'desktop_bridge_launch_guard_blocked',
             prepared: false,
             codex_exit_code: null,
             parent_summary: null,
             parent_summary_file: null,
             host_capability_runtime: hostCapabilityRuntime,
             host_capability_evidence: hostCapabilityCollector.finish(),
-            tool_output_recovery: toolOutputRecovery,
-            blockers: toolOutputRecovery.blockers,
-            operator_actions: toolOutputRecovery.operator_actions,
+            desktop_bridge_launch_guard: launchGuard,
+            blockers: launchGuard.blockers,
+            operator_actions: launchGuard.operator_actions,
             completion_evidence: false
         };
     }
@@ -536,7 +519,7 @@ export async function runOfficialSubagentWorkflow(input) {
                 parent_summary_file: null,
                 host_capability_runtime: hostCapabilityRuntime,
                 host_capability_evidence: hostCapabilityCollector.finish(),
-                tool_output_recovery: toolOutputRecovery,
+                desktop_bridge_launch_guard: launchGuard,
                 blockers: ['host_capability_pending_runtime_write_failed'],
                 completion_evidence: false
             };
@@ -611,7 +594,7 @@ export async function runOfficialSubagentWorkflow(input) {
         oauth_callback_port_diagnostic: oauthCallbackPortDiagnostic,
         host_capability_runtime: hostCapabilityRuntime,
         host_capability_evidence: hostCapabilityEvidence,
-        tool_output_recovery: toolOutputRecovery,
+        desktop_bridge_launch_guard: launchGuard,
         process: {
             pid: processResult.pid || null,
             timed_out: processResult.timedOut,

package/dist/core/subagents/wave-lifecycle.js

@@ -46,13 +46,16 @@ export function subagentCountContractBlockers(plan, observedStarts = 0) {
     const waveCapacity = positiveCount(lifecycle?.wave_capacity)
         || positiveCount(plan?.first_wave)
         || positiveCount(plan?.capacity_controller?.selected_capacity);
-    const observedWavePeak = Array.isArray(lifecycle?.waves)
+    const legacyObservedWavePeak = Array.isArray(lifecycle?.waves)
         ? lifecycle.waves.reduce((peak, wave) => {
             if (!wave || typeof wave !== 'object' || !Array.isArray(wave.thread_ids))
                 return peak;
             return Math.max(peak, new Set(wave.thread_ids.map(String).filter(Boolean)).size);
         }, 0)
         : 0;
+    const observedWavePeak = lifecycle?.peak_open_threads === undefined
+        ? legacyObservedWavePeak
+        : normalizeCount(lifecycle.peak_open_threads);
     const waveCapacityExceeded = waveCapacity > 0 && observedWavePeak > waveCapacity;
     return [
         ...(exactTargetRejected ? ['subagent_target_change_rejected'] : []),
@@ -112,6 +115,7 @@ export function createSubagentWaveLifecycle(input) {
         cumulative_completed: 0,
         cumulative_failed: 0,
         cumulative_settled: 0,
+        peak_open_threads: 0,
         open_threads: 0,
         remaining_to_start: targetSubagents,
         post_wave_rescan_required: false,
@@ -152,12 +156,16 @@ export async function refreshSubagentWaveLifecycle(artifactDir, input = {}) {
     const targetSubagents = countPolicy === 'exact' && existing
         ? requestedTargetSubagents
         : Math.min(automaticSubagentTargetCap(plan), Math.max(requestedTargetSubagents, normalizeCount(existing?.target_subagents), startedCount));
+    const waveCapacity = positiveCount(plan.first_wave)
+        || positiveCount(plan.capacity_controller?.selected_capacity)
+        || positiveCount(existing?.wave_capacity)
+        || positiveCount(plan.max_threads)
+        || targetSubagents;
     const next = projectLifecycle(existing || createSubagentWaveLifecycle({
         workflowRunId,
         targetSubagents,
         countPolicy,
-        waveCapacity: positiveCount(plan.first_wave)
-            || positiveCount(plan.capacity_controller?.selected_capacity)
+        waveCapacity
     }), {
         workflowRunId,
         requestedTargetSubagents,
@@ -165,8 +173,7 @@ export async function refreshSubagentWaveLifecycle(artifactDir, input = {}) {
         countPolicy,
         events,
         evidence: input.evidence || null,
-        waveCapacity: positiveCount(plan.first_wave)
-            || positiveCount(plan.capacity_controller?.selected_capacity),
+        waveCapacity,
         lastEvent: input.event?.event_name || null,
         targetChangeRejected: existing?.target_change_rejected === true || (countPolicy === 'exact'
             && Boolean(existing)
@@ -230,14 +237,13 @@ function projectLifecycle(previous, input) {
     const cumulativeSettled = [...stops].filter((threadId) => starts.includes(threadId)).length;
     const completed = Math.max(0, cumulativeSettled - failed.size);
     const openThreads = Math.max(0, starts.length - cumulativeSettled);
+    const peakOpenThreads = maxConcurrentOpenThreads(input.events);
     const remainingToStart = Math.max(0, input.targetSubagents - starts.length);
     const lastWave = waves.at(-1);
     const postWaveRescanRequired = Boolean(lastWave?.status === 'settled'
         && openThreads === 0
         && remainingToStart > 0);
-    const recoveredCapacity = lastWave?.status === 'settled'
-        ? lastWave.thread_ids.length
-        : 0;
+    const recoveredCapacity = Math.min(cumulativeSettled, Math.max(0, input.waveCapacity - openThreads));
     const parentGuidance = buildWaveParentGuidance({
         remaining_to_start: remainingToStart,
         open_threads: openThreads,
@@ -260,6 +266,7 @@ function projectLifecycle(previous, input) {
         cumulative_completed: completed,
         cumulative_failed: failed.size,
         cumulative_settled: cumulativeSettled,
+        peak_open_threads: peakOpenThreads,
         open_threads: openThreads,
         remaining_to_start: remainingToStart,
         post_wave_rescan_required: postWaveRescanRequired,
@@ -283,6 +290,27 @@ function normalizeLifecycle(value, workflowRunId) {
 function uniqueThreadIds(events) {
     return [...new Set(events.map((event) => event.thread_id || '').filter(Boolean))];
 }
+function maxConcurrentOpenThreads(events) {
+    const started = new Set();
+    const open = new Set();
+    let peak = 0;
+    for (const event of events) {
+        const threadId = event.thread_id;
+        if (!threadId)
+            continue;
+        if (event.event_name === 'SubagentStart') {
+            if (started.has(threadId))
+                continue;
+            started.add(threadId);
+            open.add(threadId);
+            peak = Math.max(peak, open.size);
+            continue;
+        }
+        if (started.has(threadId))
+            open.delete(threadId);
+    }
+    return peak;
+}
 function latestEventTime(events, name, threadIds) {
     const allowed = new Set(threadIds);
     return events

package/dist/core/subagents/wave-parent-guidance.js

@@ -19,7 +19,8 @@ export function buildWaveParentGuidance(lifecycle) {
     }
     if (rescan || remaining > 0) {
         actions.push(REFRESH_LIFECYCLE_ACTION);
-        const nextWaveLimit = Math.min(remaining, waveCapacity);
+        const reusableSlots = Math.max(0, waveCapacity - openThreads);
+        const nextWaveLimit = Math.min(remaining, reusableSlots);
         if (nextWaveLimit > 0) {
             actions.push(`${SPAWN_NEXT_WAVE_ACTION}:${nextWaveLimit}`);
         }

package/dist/core/telegram/doctor.js

@@ -123,8 +123,8 @@ async function probeTelegramReceipt(receiptPath, now) {
         token_configured: receipt.token_configured,
         token_source: receipt.token_source ?? (receipt.token_configured ? 'unknown' : 'none'),
         bot_identity_valid: receipt.bot_identity_valid,
-        getme_checked_at: receipt.getme_checked_at,
-        getme_latency_ms: receipt.getme_latency_ms,
+        getme_checked_at: receipt.getme_checked_at ?? null,
+        getme_latency_ms: receipt.getme_latency_ms ?? null,
         getme_check_kind: 'receipt',
         paired_chat_count: receipt.paired_chat_count,
         audit_healthy: receipt.audit_healthy !== false,

package/dist/core/telegram/liveness.js

@@ -89,8 +89,9 @@ function isTelegramLivenessReceipt(value) {
         && (row.token_source === undefined || ['env', 'user_secret_file', 'none', 'unknown'].includes(String(row.token_source)))
         && optionalPositiveSafeInteger(row.bot_id)
         && typeof row.bot_identity_valid === 'boolean'
-        && nullableIso(row.getme_checked_at)
-        && (row.getme_latency_ms === null || (Number.isFinite(row.getme_latency_ms) && Number(row.getme_latency_ms) >= 0))
+        && optionalNullableIso(row.getme_checked_at)
+        && (row.getme_latency_ms === undefined || row.getme_latency_ms === null
+            || (Number.isFinite(row.getme_latency_ms) && Number(row.getme_latency_ms) >= 0))
         && Number.isSafeInteger(row.paired_chat_count) && Number(row.paired_chat_count) >= 0
         && typeof row.started_at === 'string' && Number.isFinite(Date.parse(row.started_at))
         && typeof row.heartbeat_at === 'string' && Number.isFinite(Date.parse(row.heartbeat_at))
@@ -110,9 +111,14 @@ function isPollSnapshot(value) {
         && typeof row.running === 'boolean'
         && Number.isSafeInteger(row.offset) && Number(row.offset) >= 0
         && Number.isSafeInteger(row.consecutive_failures) && Number(row.consecutive_failures) >= 0
-        && nullableIso(row.last_poll_at) && nullableIso(row.last_success_at) && nullableIso(row.last_update_at)
-        && (row.last_error === null || typeof row.last_error === 'string');
+        && optionalNullableIso(row.last_poll_at)
+        && optionalNullableIso(row.last_success_at)
+        && optionalNullableIso(row.last_update_at)
+        && (row.last_error === undefined || row.last_error === null || typeof row.last_error === 'string');
 }
 function nullableIso(value) {
     return value === null || (typeof value === 'string' && Number.isFinite(Date.parse(value)));
 }
+function optionalNullableIso(value) {
+    return value === undefined || nullableIso(value);
+}