sneakoscope 3.1.1 → 3.1.2

package/README.md

@@ -35,7 +35,7 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## 🚀 Current Release
 
-SKS **3.1.1** is Codex 0.139-aware while it bundles @openai/codex-sdk 0.138.0 at this release boundary. It detects and uses 0.139 features from the external Codex CLI when that CLI supports them, with release gates that include hermetic fixtures and actual real probes for code-mode web search, preserved `oneOf`/`allOf` tool schemas, doctor env redaction, plugin marketplace `source` and cache behavior, the `-P` profile alias, the multi-agent v2 `interrupt_agent` rename, image referenced-path routing, sandbox/proxy preservation, Zellij stacked/fallback pane proof, pane-lock openWorkerPane integration, release cache safety fixtures, runtime proof summaries, and release proof source-truth artifacts. See [docs/codex-0.139-compat.md](docs/codex-0.139-compat.md) and [docs/codex-0.139-real-probes.md](docs/codex-0.139-real-probes.md).
+SKS **3.1.2** hardens Loop Mesh for production use: fixture workers/gates/final arbiters are test-only, `gpt:final-arbiter` is explicitly finalizer-owned, integration merge uses a strategy ladder, side-effect reports come from loop diffs and mutation ledgers, loop kill interrupts active worker sessions, and global loop concurrency budgets prevent worker/model-call oversubscription. It remains Codex 0.139-aware while bundling @openai/codex-sdk 0.138.0 at this release boundary; see [docs/codex-0.139-compat.md](docs/codex-0.139-compat.md), [docs/codex-0.139-real-probes.md](docs/codex-0.139-real-probes.md), [docs/loop-fixture-policy.md](docs/loop-fixture-policy.md), and [docs/loop-merge-strategy.md](docs/loop-merge-strategy.md).
 
 SKS 3.0.0 was the parallel-runtime stabilization release. The whole live-swarm experience — what you actually *see* while 5, 20, or 100 workers run — was rebuilt and proven end-to-end.
 

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "3.1.1"
+version = "3.1.2"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "3.1.1"
+version = "3.1.2"
 edition = "2021"
 
 [dependencies]

package/crates/sks-core/src/main.rs

@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek, SeekFrom};
 fn main() {
     let mut args = std::env::args().skip(1);
     match args.next().as_deref() {
-        Some("--version") => println!("sks-rs 3.1.1"),
+        Some("--version") => println!("sks-rs 3.1.2"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/.sks-build-stamp.json

@@ -1,8 +1,8 @@
 {
   "schema": "sks.dist-build-stamp.v1",
   "package_name": "sneakoscope",
-  "package_version": "3.1.1",
-  "source_digest": "ea95ac89533e71474a3f68a4dbf879d966eb64159ca24da208d6bb066fb7c573",
-  "source_file_count": 2410,
-  "built_at_source_time": 1781345242524
+  "package_version": "3.1.2",
+  "source_digest": "0312e2e27bae702aee9d6c07009b9492e43274c3d26e3b63a5140196997fea39",
+  "source_file_count": 2448,
+  "built_at_source_time": 1781367909038
 }

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '3.1.1';
+const FAST_PACKAGE_VERSION = '3.1.2';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

package/dist/cli/install-helpers.js

@@ -1515,7 +1515,7 @@ function normalizeCodexFastModeUiConfigOnce(text = '', opts = {}) {
     next = upsertTopLevelTomlStringIfAbsent(next, 'model', 'gpt-5.5');
     next = opts.forceFastMode === true
         ? upsertTopLevelTomlString(next, 'service_tier', 'fast')
-        : upsertTopLevelTomlStringIfAbsent(next, 'service_tier', 'fast');
+        : next;
     // Codex App feature flags / fast-mode UI / suppress-warning are SET-IF-ABSENT: a fresh
     // config still gets SKS's defaults, but SKS NEVER overrides (re-enables) a feature the
     // user disabled in the App, and never rejects-then-hides UI by forcing an unrecognized
@@ -1536,11 +1536,10 @@ function normalizeCodexFastModeUiConfigOnce(text = '', opts = {}) {
     else {
         next = upsertTomlTableKeyIfAbsent(next, 'user.fast_mode', 'visible = true');
         next = upsertTomlTableKeyIfAbsent(next, 'user.fast_mode', 'enabled = true');
-        next = upsertTomlTableKeyIfAbsent(next, 'user.fast_mode', 'default_profile = "sks-fast-high"');
+        next = removeTomlTableKey(next, 'user.fast_mode', 'default_profile');
     }
-    // Keep ONLY the sks-fast-high config-profile table: the Codex App fast-mode
-    // (`[user.fast_mode] default_profile = "sks-fast-high"`) and the
-    // codex-app:ui-preservation gate still expect it. The other SKS config profiles are
+    // Keep ONLY the sks-fast-high config-profile table for explicit fast-mode opt-in
+    // and CLI `--profile` use. The other SKS config profiles are
     // no longer written as `[profiles.sks-*]` tables here (Codex 0.134+ deprecates them);
     // they are managed as per-file `<name>.config.toml` overlays by
     // migrateSksProfilesToPerFile (src/core/auto-review.ts), which also writes the
@@ -2953,8 +2952,8 @@ export async function selftestCodexLb(tmp) {
     });
     if (brokenChain.ok || brokenChain.status !== 'previous_response_not_found' || brokenChain.chain_unhealthy !== true)
         throw new Error('selftest: codex-lb response chain health check did not detect previous_response_not_found');
-    if (!/^model = "gpt-5\.5"/m.test(codexLbConfig) || !codexLbConfig.includes('service_tier = "fast"') || !codexLbConfig.includes('hooks = true') || hasDeprecatedCodexHooksFeatureFlag(codexLbConfig) || !codexLbConfig.includes('remote_control = true') || !codexLbConfig.includes('multi_agent = true') || !codexLbConfig.includes('fast_mode = true') || !codexLbConfig.includes('fast_mode_ui = true') || !codexLbConfig.includes('codex_git_commit = true') || !codexLbConfig.includes('computer_use = true') || !codexLbConfig.includes('browser_use = true') || !codexLbConfig.includes('browser_use_external = true') || !codexLbConfig.includes('guardian_approval = true') || !codexLbConfig.includes('tool_suggest = true') || !codexLbConfig.includes('apps = true') || !codexLbConfig.includes('plugins = true') || !codexLbConfig.includes('[plugins."latex@openai-bundled"]') || !codexLbConfig.includes('[plugins."documents@openai-primary-runtime"]') || !codexLbConfig.includes('[user.fast_mode]') || !codexLbConfig.includes('visible = true') || !codexLbConfig.includes('enabled = true') || !codexLbConfig.includes('default_profile = "sks-fast-high"') || !/\[profiles\.custom\][\s\S]*?model_reasoning_effort = "low"/.test(codexLbConfig) || !/\[profiles\.sks-fast-high\][\s\S]*?service_tier = "fast"/.test(codexLbConfig) || codexLbConfig.includes('fast_default_opt_out = true') || hasTopLevelCodexModeLock(codexLbConfig))
-        throw new Error('selftest: codex-lb setup did not preserve Codex App feature flags, default plugins, profile-scoped reasoning effort, Fast mode defaults, Codex Git commit generation, force GPT-5.5, or migrate the hooks feature flag');
+    if (!/^model = "gpt-5\.5"/m.test(codexLbConfig) || !codexLbConfig.includes('hooks = true') || hasDeprecatedCodexHooksFeatureFlag(codexLbConfig) || !codexLbConfig.includes('remote_control = true') || !codexLbConfig.includes('multi_agent = true') || !codexLbConfig.includes('fast_mode = true') || !codexLbConfig.includes('fast_mode_ui = true') || !codexLbConfig.includes('codex_git_commit = true') || !codexLbConfig.includes('computer_use = true') || !codexLbConfig.includes('browser_use = true') || !codexLbConfig.includes('browser_use_external = true') || !codexLbConfig.includes('guardian_approval = true') || !codexLbConfig.includes('tool_suggest = true') || !codexLbConfig.includes('apps = true') || !codexLbConfig.includes('plugins = true') || !codexLbConfig.includes('[plugins."latex@openai-bundled"]') || !codexLbConfig.includes('[plugins."documents@openai-primary-runtime"]') || !codexLbConfig.includes('[user.fast_mode]') || !codexLbConfig.includes('visible = true') || !codexLbConfig.includes('enabled = true') || !/\[profiles\.custom\][\s\S]*?model_reasoning_effort = "low"/.test(codexLbConfig) || !/\[profiles\.sks-fast-high\][\s\S]*?service_tier = "fast"/.test(codexLbConfig) || codexLbConfig.includes('fast_default_opt_out = true') || hasTopLevelCodexModeLock(codexLbConfig))
+        throw new Error('selftest: codex-lb setup did not preserve Codex App feature flags, default plugins, profile-scoped reasoning effort, explicit Fast profile, Codex Git commit generation, force GPT-5.5, or migrate the hooks feature flag');
     if (!hasCodexUnstableFeatureWarningSuppression(codexLbConfig))
         throw new Error('selftest: codex-lb setup did not suppress Codex unstable feature warning');
     const codexLbLaunch = `source ${path.join(tmp, '.codex', 'sks-codex-lb.env')} && codex '--model' 'gpt-5.5'`;

package/dist/core/agents/agent-orchestrator.js

@@ -49,6 +49,7 @@ import { applyFastModeToRoster, resolveFastModePolicy, writeFastModePropagationP
 import { createNativeCliSessionSwarmRecorder } from './native-cli-session-swarm.js';
 import { writeNativeCliSessionProof } from './native-cli-session-proof.js';
 import { writeNoSubagentScalingPolicy } from './no-subagent-scaling-policy.js';
+import { writeOfficialSubagentHelperPolicy } from './official-subagent-helper-policy.js';
 import { runCodexTask } from '../codex-control/codex-control-plane.js';
 import { CODEX_AGENT_WORKER_RESULT_SCHEMA_ID, codexAgentWorkerResultSchema } from '../codex-control/schemas/agent-worker-result.schema.js';
 import { resolveLocalCollaborationPolicy, localCollaborationParticipated } from '../local-llm/local-collaboration-policy.js';
@@ -255,7 +256,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         total_work_items: partition.task_graph?.total_work_items || partition.slices.length,
         service_tier: fastModePolicy.service_tier,
         fast_mode: fastModePolicy.fast_mode,
-        fast_mode_default: true,
+        fast_mode_default: fastModePolicy.default_fast_mode,
         backpressure: 'dynamic scheduler maintains target active slots until the work queue drains',
         rate_limit_delay_ms: backend === 'codex-sdk' ? 250 : 0,
         resource_pressure_warnings: roster.agent_count > roster.concurrency ? ['agents_exceed_concurrency_batches'] : []
@@ -487,7 +488,8 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         targetActiveSlots,
         totalWorkItems: partition.task_graph?.total_work_items || partition.slices.length
     });
-    const noSubagentScalingPolicy = await writeNoSubagentScalingPolicy(ledgerRoot, { nativeProof: nativeCliSessionProof });
+    const officialSubagentHelperPolicy = await writeOfficialSubagentHelperPolicy(ledgerRoot, { nativeProof: nativeCliSessionProof });
+    const noSubagentScalingPolicy = await writeNoSubagentScalingPolicy(ledgerRoot, { nativeProof: nativeCliSessionProof, officialSubagentHelperPolicy });
     const fastModePropagation = await writeFastModePropagationProof(ledgerRoot, { policy: fastModePolicy, backend, results });
     const localCollaborationPolicy = resolveLocalCollaborationPolicy();
     await writeJsonAtomic(path.join(ledgerRoot, 'local-collaboration-policy.json'), localCollaborationPolicy);
@@ -560,6 +562,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         ...(timeoutKill.killed_sessions || []).map((id) => 'timeout_killed:' + id),
         ...(recursion.ok ? [] : recursion.violations.map((id) => 'recursion:' + id)),
         ...(nativeCliSessionProof.ok ? [] : nativeCliSessionProof.blockers),
+        ...(officialSubagentHelperPolicy.ok ? [] : officialSubagentHelperPolicy.blockers),
         ...(noSubagentScalingPolicy.ok ? [] : noSubagentScalingPolicy.blockers),
         ...(fastModePropagation.ok ? [] : fastModePropagation.blockers),
         ...(gitWorktreeRuntime.required === true && gitWorktreeRuntime.ok === false ? gitWorktreeRuntime.blockers || ['git_worktree_runtime_not_ok'] : []),
@@ -597,6 +600,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         strategyGate,
         nativeCliSessionProof,
         noSubagentScalingPolicy,
+        officialSubagentHelperPolicy,
         fastModePolicy,
         fastModePropagation,
         gitWorktreeRuntime,
@@ -642,6 +646,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         parallel_write_policy: parallelWritePolicy,
         native_cli_session_proof: nativeCliSessionProof,
         no_subagent_scaling_policy: noSubagentScalingPolicy,
+        official_subagent_helper_policy: officialSubagentHelperPolicy,
         fast_mode_policy: fastModePolicy,
         fast_mode_propagation: fastModePropagation,
         git_worktree_runtime: gitWorktreeRuntime,

package/dist/core/agents/agent-proof-evidence.js

@@ -51,6 +51,7 @@ export async function writeAgentProofEvidence(root, input) {
     });
     const nativeCliSessionProof = input.nativeCliSessionProof || await readJson(path.join(root, 'native-cli-session-proof.json'), null);
     const noSubagentScalingPolicy = input.noSubagentScalingPolicy || await readJson(path.join(root, 'no-subagent-scaling-policy.json'), null);
+    const officialSubagentHelperPolicy = input.officialSubagentHelperPolicy || await readJson(path.join(root, 'official-subagent-helper-policy.json'), null);
     const fastModePropagation = input.fastModePropagation || await readJson(path.join(root, 'fast-mode-propagation-proof.json'), null);
     const zellijPaneProof = await readJson(path.join(root, 'zellij-pane-proof.json'), null);
     const cleanupProof = await readJson(path.join(root, 'agent-cleanup-proof.json'), null);
@@ -179,6 +180,7 @@ export async function writeAgentProofEvidence(root, input) {
         ...(input.results || []).flatMap((result) => result.blockers || []),
         ...(nativeCliSessionProof?.ok === false ? nativeCliSessionProof.blockers || ['native_cli_session_proof_not_ok'] : []),
         ...(noSubagentScalingPolicy?.ok === false ? noSubagentScalingPolicy.blockers || ['no_subagent_scaling_policy_not_ok'] : []),
+        ...(officialSubagentHelperPolicy?.ok === false ? officialSubagentHelperPolicy.blockers || ['official_subagent_helper_policy_not_ok'] : []),
         ...(fastModePropagation?.ok === false ? fastModePropagation.blockers || ['fast_mode_propagation_not_ok'] : []),
         ...(patchSwarm?.ok === false ? patchSwarm.blockers || ['patch_swarm_not_ok'] : []),
         ...(gitWorktreeRuntime?.required === true && gitWorktreeRuntime?.ok === false ? gitWorktreeRuntime.blockers || ['git_worktree_runtime_not_ok'] : []),
@@ -225,6 +227,23 @@ export async function writeAgentProofEvidence(root, input) {
         native_cli_session_proof: nativeCliSessionProof ? 'native-cli-session-proof.json' : null,
         native_cli_session_swarm: nativeCliSessionProof ? 'agent-native-cli-session-swarm.json' : null,
         no_subagent_scaling_policy: noSubagentScalingPolicy ? 'no-subagent-scaling-policy.json' : null,
+        official_subagent_helper_policy: officialSubagentHelperPolicy ? 'official-subagent-helper-policy.json' : null,
+        official_subagent_helper_lane_enabled: officialSubagentHelperPolicy?.official_codex_subagent_helper_lane_enabled === true,
+        official_subagent_helper_lane_ok: officialSubagentHelperPolicy?.ok === true,
+        official_subagent_helper_worker_capacity_credit: Number(officialSubagentHelperPolicy?.worker_capacity_credit || 0),
+        official_subagent_helper_observed_subagent_event_count: Number(officialSubagentHelperPolicy?.observed_subagent_event_count || 0),
+        official_subagent_helper_events_counted_as_worker_sessions: officialSubagentHelperPolicy?.subagent_events_counted_as_worker_sessions === true,
+        official_subagent_helper_capacity_source: officialSubagentHelperPolicy?.worker_capacity_source || null,
+        official_subagent_helper_parallel_allowed: officialSubagentHelperPolicy?.helper_lane_may_run_in_parallel_with_native_workers === true,
+        official_subagent_helper_capabilities: officialSubagentHelperPolicy?.codex_app_capabilities_allowed || [],
+        official_subagent_helper_builtin_agents: officialSubagentHelperPolicy?.built_in_agents_allowed || [],
+        official_subagent_helper_required_output_proof_for_generated_images: officialSubagentHelperPolicy?.required_output_proof_for_generated_images || [],
+        codex_builtin_imagegen_helper_allowed: officialSubagentHelperPolicy?.codex_builtin_imagegen_helper_allowed === true,
+        codex_builtin_imagegen_required_surface: officialSubagentHelperPolicy?.preferred_image_generation_surface || null,
+        codex_builtin_imagegen_evidence_class: officialSubagentHelperPolicy?.codex_app_builtin_evidence_class || null,
+        imagegen_api_fallback_evidence_class: officialSubagentHelperPolicy?.api_fallback_evidence_class || null,
+        imagegen_provider_surface_evidence_required: officialSubagentHelperPolicy?.provider_surface_evidence_required === true,
+        imagegen_api_fallback_counts_as_codex_app_evidence: officialSubagentHelperPolicy?.imagegen_api_fallback_counts_as_codex_app_evidence === true,
         fast_mode_policy: input.fastModePolicy || null,
         fast_mode_propagation: fastModePropagation ? 'fast-mode-propagation-proof.json' : null,
         native_cli_worker_process_count: Number(nativeCliSessionProof?.spawned_worker_process_count || 0),
@@ -403,6 +422,7 @@ export async function writeAgentProofEvidence(root, input) {
             'gpt-final-arbiter/gpt-final-arbiter.json': gptFinalArbiter,
             'native-cli-session-proof.json': nativeCliSessionProof,
             'no-subagent-scaling-policy.json': noSubagentScalingPolicy,
+            'official-subagent-helper-policy.json': officialSubagentHelperPolicy,
             'fast-mode-propagation-proof.json': fastModePropagation
         }
     });

package/dist/core/agents/fast-mode-policy.js

@@ -18,15 +18,17 @@ export function resolveFastModePolicy(input = {}) {
             ? 'standard'
             : preference?.mode === 'standard'
                 ? 'standard'
-                : 'fast';
+                : explicitFast || explicitTier === 'fast' || preference?.mode === 'fast'
+                    ? 'fast'
+                    : 'standard';
     return {
         schema: FAST_MODE_POLICY_SCHEMA,
         generated_at: nowIso(),
         fast_mode: serviceTier === 'fast',
         service_tier: serviceTier,
         codex_desktop_service_tier: codexDesktopServiceTier(serviceTier),
-        default_fast_mode: true,
-        disabled_by: explicitNoFast ? 'no-fast' : explicitTier === 'standard' ? 'service-tier-standard' : preference?.mode === 'standard' ? 'preference-standard' : 'none',
+        default_fast_mode: false,
+        disabled_by: explicitNoFast ? 'no-fast' : explicitTier === 'standard' ? 'service-tier-standard' : preference?.mode === 'standard' ? 'preference-standard' : serviceTier === 'standard' ? 'default-standard' : 'none',
         explicit_fast: explicitFast,
         explicit_no_fast: explicitNoFast,
         explicit_service_tier: explicitTier,
@@ -125,7 +127,7 @@ export async function writeFastModePropagationProof(root, input = { policy: reso
     const agentProcessReports = await collectNamedJson(root, 'agent-process-report.json');
     const zellijReports = await collectNamedJson(root, 'agent-zellij-report.json');
     const madReports = await collectNamedJson(root, 'mad-sks-worker-report.json');
-    const defaultFastExpected = input.policy.disabled_by === 'none';
+    const defaultFastExpected = input.policy.fast_mode === true;
     const childReports = [...workerFastReports, ...workerProcessReports, ...agentProcessReports, ...zellijReports, ...madReports];
     const missingFast = defaultFastExpected
         ? childReports.filter((row) => row.json?.fast_mode !== true && row.json?.fast_mode !== 'true')
@@ -144,7 +146,7 @@ export async function writeFastModePropagationProof(root, input = { policy: reso
         ok: missingFast.length === 0 && missingTier.length === 0 && workerMissing.length === 0 && missingCliOverride.length === 0,
         policy: input.policy,
         backend: input.backend || null,
-        default_fast_mode: true,
+        default_fast_mode: input.policy.default_fast_mode,
         service_tier: input.policy.service_tier,
         fast_mode: input.policy.fast_mode,
         worker_fast_report_count: workerFastReports.length,

package/dist/core/agents/intelligent-work-graph.js

@@ -112,6 +112,12 @@ export function enhanceTaskGraphWithIntelligence(taskGraph, graph) {
 }
 export async function writeIntelligentWorkGraphArtifacts(root, graph) {
     const compact = compactIntelligentWorkGraph(graph);
+    const symbolOwnership = compactSymbolOwnershipMap(graph);
+    const routeOwnership = limitRecordOfArrays(graph.route_to_module_ownership, graphRecordLimit(), graphArrayLimit());
+    const commandOwnership = limitRecordOfArrays(graph.command_to_module_ownership, graphRecordLimit(), graphArrayLimit());
+    const testOwnership = compactTestOwnershipMap(graph.test_ownership_map);
+    const criticalPath = compactCriticalPath(graph.critical_path);
+    const integrationBottlenecks = compactIntegrationBottlenecks(graph.integration_bottlenecks);
     await writeJsonAtomic(path.join(root, 'agent-intelligent-work-graph.json'), compact);
     await writeJsonAtomic(path.join(root, 'agent-intelligent-work-graph-v2.json'), compact);
     await writeJsonAtomic(path.join(root, 'agent-symbol-ownership-map.json'), {
@@ -119,23 +125,19 @@ export async function writeIntelligentWorkGraphArtifacts(root, graph) {
         generated_at: graph.generated_at,
         ok: Object.keys(graph.symbol_to_files).length > 0,
         ast_coverage: graph.ast_coverage,
-        file_to_symbols: graph.file_to_symbols,
-        symbol_to_files: graph.symbol_to_files,
-        exported_symbols: graph.exported_symbols,
-        imported_symbols: graph.imported_symbols,
-        exported_api_ownership: graph.exported_api_ownership
+        ...symbolOwnership
     });
     await writeJsonAtomic(path.join(root, 'agent-route-ownership-map.json'), {
         schema: 'sks.agent-route-ownership-map.v1',
         generated_at: graph.generated_at,
         ok: Object.keys(graph.route_to_module_ownership).length > 0,
-        route_to_module_ownership: graph.route_to_module_ownership
+        route_to_module_ownership: routeOwnership
     });
     await writeJsonAtomic(path.join(root, 'agent-command-ownership-map.json'), {
         schema: 'sks.agent-command-ownership-map.v1',
         generated_at: graph.generated_at,
         ok: Object.keys(graph.command_to_module_ownership).length > 0,
-        command_to_module_ownership: graph.command_to_module_ownership
+        command_to_module_ownership: commandOwnership
     });
     await writeJsonAtomic(path.join(root, 'agent-test-ownership-map.json'), {
         schema: 'sks.agent-test-ownership-map.v1',
@@ -143,7 +145,7 @@ export async function writeIntelligentWorkGraphArtifacts(root, graph) {
         ok: graph.test_ownership_map.unmapped_sources.length < Math.max(10, graph.source_inventory_count),
         ast_coverage: graph.ast_coverage,
         test_ownership_confidence: graph.test_ownership_confidence,
-        ...graph.test_ownership_map
+        ...testOwnership
     });
     await writeJsonAtomic(path.join(root, 'agent-source-test-ownership-v2.json'), {
         schema: 'sks.agent-source-test-ownership.v2',
@@ -151,14 +153,14 @@ export async function writeIntelligentWorkGraphArtifacts(root, graph) {
         ok: graph.test_ownership_confidence > 0,
         ast_coverage: graph.ast_coverage,
         test_ownership_confidence: graph.test_ownership_confidence,
-        source_to_test_relations: graph.source_to_test_relations,
-        ...graph.test_ownership_map
+        source_to_test_relations: testOwnership.relations,
+        ...testOwnership
     });
     await writeJsonAtomic(path.join(root, 'agent-critical-path.json'), {
         schema: 'sks.agent-critical-path.v1',
         generated_at: graph.generated_at,
         ok: graph.critical_path.path.length > 0,
-        ...graph.critical_path
+        ...criticalPath
     });
     await writeJsonAtomic(path.join(root, 'agent-critical-path-v2.json'), {
         schema: 'sks.agent-critical-path.v2',
@@ -166,21 +168,21 @@ export async function writeIntelligentWorkGraphArtifacts(root, graph) {
         ok: graph.critical_path.path.length > 0,
         ast_coverage: graph.ast_coverage,
         critical_path_confidence: graph.critical_path.confidence || graph.test_ownership_confidence,
-        ...graph.critical_path
+        ...criticalPath
     });
     await writeJsonAtomic(path.join(root, 'agent-integration-bottlenecks.json'), {
         schema: 'sks.agent-integration-bottlenecks.v1',
         generated_at: graph.generated_at,
         ok: true,
         critical_path_confidence: graph.critical_path.confidence || null,
-        ...graph.integration_bottlenecks
+        ...integrationBottlenecks
     });
     await writeJsonAtomic(path.join(root, 'agent-integration-bottlenecks-v2.json'), {
         schema: 'sks.agent-integration-bottlenecks.v2',
         generated_at: graph.generated_at,
         ok: true,
         critical_path_confidence: graph.critical_path.confidence || null,
-        ...graph.integration_bottlenecks
+        ...integrationBottlenecks
     });
 }
 export function compactIntelligentWorkGraph(graph) {
@@ -222,6 +224,83 @@ export function compactIntelligentWorkGraph(graph) {
 function limitArray(items, limit) {
     return Array.isArray(items) ? items.slice(0, limit) : [];
 }
+function graphRecordLimit() {
+    return Math.max(50, Math.floor(Number(process.env.SKS_WORK_GRAPH_RECORD_LIMIT || 500) || 500));
+}
+function graphArrayLimit() {
+    return Math.max(10, Math.floor(Number(process.env.SKS_WORK_GRAPH_ARRAY_LIMIT || 50) || 50));
+}
+function graphRelationLimit() {
+    return Math.max(100, Math.floor(Number(process.env.SKS_WORK_GRAPH_RELATION_LIMIT || 1000) || 1000));
+}
+function limitRecordOfArrays(record, entryLimit, arrayLimit) {
+    const out = {};
+    for (const [key, value] of Object.entries(record || {}).slice(0, entryLimit)) {
+        out[key] = Array.isArray(value) ? value.slice(0, arrayLimit) : value;
+    }
+    return out;
+}
+function compactSymbolOwnershipMap(graph) {
+    const entryLimit = graphRecordLimit();
+    const arrayLimit = graphArrayLimit();
+    const exportedApiOwnership = {};
+    for (const [symbol, file] of Object.entries(graph.exported_api_ownership || {}).slice(0, entryLimit))
+        exportedApiOwnership[symbol] = String(file);
+    return {
+        compact: true,
+        limits: { record_entries: entryLimit, array_items: arrayLimit },
+        original_counts: {
+            file_to_symbols: Object.keys(graph.file_to_symbols || {}).length,
+            symbol_to_files: Object.keys(graph.symbol_to_files || {}).length,
+            exported_symbols: Object.keys(graph.exported_symbols || {}).length,
+            imported_symbols: Object.keys(graph.imported_symbols || {}).length,
+            exported_api_ownership: Object.keys(graph.exported_api_ownership || {}).length
+        },
+        file_to_symbols: limitRecordOfArrays(graph.file_to_symbols, entryLimit, arrayLimit),
+        symbol_to_files: limitRecordOfArrays(graph.symbol_to_files, entryLimit, arrayLimit),
+        exported_symbols: limitRecordOfArrays(graph.exported_symbols, entryLimit, arrayLimit),
+        imported_symbols: limitRecordOfArrays(graph.imported_symbols, entryLimit, arrayLimit),
+        exported_api_ownership: exportedApiOwnership
+    };
+}
+function compactTestOwnershipMap(map = {}) {
+    const entryLimit = graphRecordLimit();
+    const arrayLimit = graphArrayLimit();
+    const relationLimit = graphRelationLimit();
+    const relations = limitArray((Array.isArray(map.relations) ? map.relations : []).map((row) => ({
+        ...row,
+        symbol_overlap: limitArray(row?.symbol_overlap, arrayLimit)
+    })), relationLimit);
+    return {
+        compact: true,
+        limits: { owner_entries: entryLimit, owner_items: arrayLimit, relations: relationLimit },
+        original_counts: {
+            owner_by_source: Object.keys(map.owner_by_source || {}).length,
+            unmapped_sources: Array.isArray(map.unmapped_sources) ? map.unmapped_sources.length : 0,
+            relations: Array.isArray(map.relations) ? map.relations.length : 0
+        },
+        owner_by_source: limitRecordOfArrays(map.owner_by_source, entryLimit, arrayLimit),
+        mapped_source_count: Number(map.mapped_source_count || 0),
+        unmapped_sources: limitArray(map.unmapped_sources, entryLimit),
+        relations
+    };
+}
+function compactCriticalPath(criticalPath = {}) {
+    return {
+        ...criticalPath,
+        path: limitArray(criticalPath.path, 500),
+        compact: true,
+        original_path_length: Array.isArray(criticalPath.path) ? criticalPath.path.length : 0
+    };
+}
+function compactIntegrationBottlenecks(bottlenecks = {}) {
+    return {
+        ...bottlenecks,
+        bottlenecks: limitArray(bottlenecks.bottlenecks, 200),
+        changed_bottlenecks: limitArray(bottlenecks.changed_bottlenecks, 200),
+        compact: true
+    };
+}
 function buildTestOwnershipMap(sourceFiles, testFiles, ast, dependencyGraph = {}) {
     const ownerBySource = {};
     const relations = [];

package/dist/core/agents/native-cli-session-swarm.js

@@ -12,6 +12,7 @@ import { resolveZellijWorkerPaneUiMode } from '../zellij/zellij-ui-mode.js';
 import { appendZellijSlotTelemetry } from '../zellij/zellij-slot-telemetry.js';
 import { appendParallelRuntimeEvent } from './parallel-runtime-proof.js';
 import { appendAgentMessage } from './agent-message-bus.js';
+import { markLoopWorkerInterrupted, registerLoopActiveWorker } from '../loops/loop-interrupt-registry.js';
 export const NATIVE_CLI_SESSION_SWARM_SCHEMA = 'sks.agent-native-cli-session-swarm.v1';
 export function createNativeCliSessionSwarmRecorder(root, input) {
     return new NativeCliSessionSwarmRecorder(root, input);
@@ -176,6 +177,13 @@ class NativeCliSessionSwarmRecorder {
         });
         record.pid = child.pid || null;
         record.process_id = child.pid || null;
+        const loopHandle = await registerLoopWorkerHandle({
+            root: ctx.opts.projectRoot || this.input.projectRoot || ctx.opts.cwd || packageRoot(),
+            env: ctx.opts.env || {},
+            agentId: String(ctx.agent.id || ctx.agent.session_id || 'agent'),
+            sessionId: ctx.agent.session_id || null,
+            pid: child.pid || null
+        });
         record.status = 'running';
         await appendParallelRuntimeEvent(this.root, this.input.missionId, {
             event_type: 'worker_process_spawned',
@@ -211,6 +219,9 @@ class NativeCliSessionSwarmRecorder {
         record.exit_code = exit.code;
         record.signal = exit.signal;
         record.status = exit.code === 0 ? 'closed' : 'failed';
+        if (loopHandle) {
+            await markLoopWorkerInterrupted(ctx.opts.projectRoot || this.input.projectRoot || ctx.opts.cwd || packageRoot(), loopHandle.mission_id, loopHandle.worker_id, record.status === 'closed' ? 'completed' : 'failed').catch(() => undefined);
+        }
         if (record.worker_placement === 'headless') {
             await closeWorkerInRightColumn({
                 root: this.root,
@@ -343,6 +354,13 @@ class NativeCliSessionSwarmRecorder {
                 stdoutRel: input.stdoutRel,
                 stderrRel: input.stderrRel
             });
+        let loopHandle = await registerLoopWorkerHandle({
+            root: input.ctx.opts.projectRoot || this.input.projectRoot || input.ctx.opts.cwd || packageRoot(),
+            env: input.ctx.opts.env || {},
+            agentId: String(input.ctx.agent.id || input.ctx.agent.session_id || 'agent'),
+            sessionId: input.ctx.agent.session_id || null,
+            pid: processRun?.pid || null
+        });
         if (processRun?.pid) {
             input.record.pid = processRun.pid;
             input.record.process_id = processRun.pid;
@@ -542,6 +560,15 @@ class NativeCliSessionSwarmRecorder {
         }
         input.record.pid = Number(workerProcessReport?.pid || processRun?.pid) || null;
         input.record.process_id = input.record.pid;
+        if (!loopHandle && input.record.pid) {
+            loopHandle = await registerLoopWorkerHandle({
+                root: input.ctx.opts.projectRoot || this.input.projectRoot || input.ctx.opts.cwd || packageRoot(),
+                env: input.ctx.opts.env || {},
+                agentId: String(input.ctx.agent.id || input.ctx.agent.session_id || 'agent'),
+                sessionId: input.ctx.agent.session_id || null,
+                pid: input.record.pid
+            });
+        }
         input.record.compact_worker_exit_code = compactExit?.code ?? null;
         input.record.compact_worker_signal = compactExit?.signal ?? null;
         input.record.sdk_thread_id = sdkThreadId;
@@ -550,6 +577,9 @@ class NativeCliSessionSwarmRecorder {
         input.record.structured_output_valid = workerProcessReport?.structured_output_valid === true || workerProcessReport?.backend_router_report?.structured_output_valid === true;
         input.record.exit_code = parsed ? (parsed.status === 'done' ? 0 : 1) : 1;
         input.record.status = parsed?.status === 'done' ? 'closed' : 'failed';
+        if (loopHandle) {
+            await markLoopWorkerInterrupted(input.ctx.opts.projectRoot || this.input.projectRoot || input.ctx.opts.cwd || packageRoot(), loopHandle.mission_id, loopHandle.worker_id, input.record.status === 'closed' ? 'completed' : 'failed').catch(() => undefined);
+        }
         const heartbeatOk = await hasHeartbeat(path.join(this.root, input.heartbeatRel));
         input.record.blockers = [
             ...(parsed ? parsed.blockers || [] : ['zellij_worker_result_timeout']),
@@ -915,6 +945,22 @@ function normalizeParallelPlacement(value) {
         return text;
     return 'unknown';
 }
+async function registerLoopWorkerHandle(input) {
+    const missionId = String(input.env.SKS_MISSION_ID || input.env.SKS_PARENT_MISSION_ID || '').trim();
+    const loopId = String(input.env.SKS_LOOP_ID || '').trim();
+    const phase = String(input.env.SKS_LOOP_PHASE || '').trim();
+    if (!missionId || !loopId || (phase !== 'maker' && phase !== 'checker'))
+        return null;
+    return registerLoopActiveWorker(input.root, {
+        mission_id: missionId,
+        loop_id: loopId,
+        phase,
+        worker_id: input.agentId,
+        session_id: input.sessionId,
+        pid: input.pid,
+        interrupt_supported: Boolean(input.pid || input.sessionId)
+    }).catch(() => null);
+}
 async function tailFile(file, max) {
     try {
         const text = await fs.promises.readFile(file, 'utf8');

package/dist/core/agents/no-subagent-scaling-policy.js

@@ -3,6 +3,7 @@ import { nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
 export const NO_SUBAGENT_SCALING_POLICY_SCHEMA = 'sks.no-subagent-scaling-policy.v1';
 export async function writeNoSubagentScalingPolicy(root, input = {}) {
     const nativeProof = input.nativeProof || await readJson(path.join(root, 'native-cli-session-proof.json'), null);
+    const officialSubagentHelperPolicy = input.officialSubagentHelperPolicy || await readJson(path.join(root, 'official-subagent-helper-policy.json'), null);
     const swarm = await readJson(path.join(root, 'agent-native-cli-session-swarm.json'), null);
     const events = await readText(path.join(root, 'agent-events.jsonl'), '');
     const subagentEventCount = String(events).split(/\n/).filter((line) => /Subagent(Start|Stop)|subagent/i.test(line)).length;
@@ -11,7 +12,8 @@ export async function writeNoSubagentScalingPolicy(root, input = {}) {
     const blockers = [
         ...(allowedScalingPrimitives.has(String(swarm?.scaling_primitive || '')) ? [] : ['main_scaling_primitive_not_native_cli_process']),
         ...(nativeProcessCount > 0 ? [] : ['native_cli_worker_process_proof_missing']),
-        ...(nativeProof?.worker_proof_is_only_subagent_events === true ? ['worker_proof_only_subagent_events'] : [])
+        ...(nativeProof?.worker_proof_is_only_subagent_events === true ? ['worker_proof_only_subagent_events'] : []),
+        ...(officialSubagentHelperPolicy?.ok === false ? officialSubagentHelperPolicy.blockers || ['official_subagent_helper_policy_not_ok'] : [])
     ];
     const report = {
         schema: NO_SUBAGENT_SCALING_POLICY_SCHEMA,
@@ -21,6 +23,13 @@ export async function writeNoSubagentScalingPolicy(root, input = {}) {
         subagent_events_counted_as_worker_sessions: false,
         scout_events_counted_as_worker_sessions: false,
         worker_internal_scout_usage_allowed_as_helper_only: true,
+        official_codex_subagent_helper_lane_allowed: officialSubagentHelperPolicy?.ok !== false,
+        official_codex_subagent_helper_policy: officialSubagentHelperPolicy ? 'official-subagent-helper-policy.json' : null,
+        official_helper_lane_worker_capacity_credit: 0,
+        official_helper_lane_observed_subagent_event_count: Number(officialSubagentHelperPolicy?.observed_subagent_event_count || 0),
+        official_helper_lane_events_counted_as_worker_sessions: false,
+        codex_builtin_capability_lane_allowed: officialSubagentHelperPolicy?.official_codex_subagent_helper_lane_enabled === true,
+        codex_builtin_imagegen_helper_allowed: officialSubagentHelperPolicy?.codex_builtin_imagegen_helper_allowed === true,
         native_worker_process_count: nativeProcessCount,
         subagent_event_count: subagentEventCount,
         worker_process_proof: 'native-cli-session-proof.json',

package/dist/core/agents/official-subagent-helper-policy.js

@@ -0,0 +1,62 @@
+import path from 'node:path';
+import { nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
+export const OFFICIAL_SUBAGENT_HELPER_POLICY_SCHEMA = 'sks.official-subagent-helper-policy.v1';
+export async function writeOfficialSubagentHelperPolicy(root, input = {}) {
+    const nativeProof = input.nativeProof || await readJson(path.join(root, 'native-cli-session-proof.json'), null);
+    const events = await readText(path.join(root, 'agent-events.jsonl'), '');
+    const subagentEventCount = String(events).split(/\n/).filter((line) => /Subagent(Start|Stop)|subagent/i.test(line)).length;
+    const nativeProcessCount = Number(nativeProof?.spawned_worker_process_count || 0);
+    const workerCapacityCredit = 0;
+    const subagentEventsCountedAsWorkerSessions = false;
+    const builtInAgentsAllowed = ['default', 'worker', 'explorer'];
+    const codexAppCapabilitiesAllowed = [
+        'image_generation',
+        'computer_use_for_native_app_targets',
+        'in_app_browser_for_allowed_web_targets',
+        'web_search',
+        'mcp_tools',
+        'product_design_plugin'
+    ];
+    const requiredOutputProofForGeneratedImages = ['path', 'sha256', 'bytes', 'dimensions', 'model_or_surface'];
+    const blockers = [
+        ...(workerCapacityCredit === 0 ? [] : ['official_helper_worker_capacity_credit_not_zero']),
+        ...(subagentEventsCountedAsWorkerSessions === false ? [] : ['official_helper_subagent_events_counted_as_worker_sessions']),
+        ...(codexAppCapabilitiesAllowed.includes('image_generation') ? [] : ['official_helper_image_generation_capability_missing']),
+        ...(requiredOutputProofForGeneratedImages.includes('sha256') && requiredOutputProofForGeneratedImages.includes('dimensions')
+            ? []
+            : ['official_helper_image_output_proof_incomplete'])
+    ];
+    const report = {
+        schema: OFFICIAL_SUBAGENT_HELPER_POLICY_SCHEMA,
+        generated_at: nowIso(),
+        ok: blockers.length === 0,
+        official_codex_subagent_helper_lane_enabled: true,
+        official_codex_subagents_allowed: true,
+        helper_lane_role: 'capability_helper_only',
+        helper_lane_may_run_in_parallel_with_native_workers: true,
+        worker_capacity_source: 'native-cli-session-proof.json',
+        worker_capacity_credit: workerCapacityCredit,
+        subagent_events_counted_as_worker_sessions: subagentEventsCountedAsWorkerSessions,
+        native_worker_process_count: nativeProcessCount,
+        observed_subagent_event_count: subagentEventCount,
+        built_in_agents_allowed: builtInAgentsAllowed,
+        codex_app_capabilities_allowed: codexAppCapabilitiesAllowed,
+        codex_builtin_imagegen_helper_allowed: true,
+        preferred_image_generation_surface: 'Codex App $imagegen/gpt-image-2',
+        codex_app_builtin_evidence_class: 'codex_app_builtin',
+        api_fallback_evidence_class: 'api_fallback',
+        provider_surface_evidence_required: true,
+        imagegen_api_fallback_counts_as_codex_app_evidence: false,
+        required_output_proof_for_generated_images: requiredOutputProofForGeneratedImages,
+        proof_rule: 'Official Codex subagents and app tools may assist native workers, but never increase requested_agents, target_active_slots, spawned_worker_process_count, or max_observed_worker_process_count.',
+        limitations: [
+            'helper_subagent_events_do_not_prove_worker_capacity',
+            'codex_app_capability_detection_is_not_generated_output_proof',
+            'image_generation_claims_require_real_raster_output_evidence'
+        ],
+        blockers
+    };
+    await writeJsonAtomic(path.join(root, 'official-subagent-helper-policy.json'), report);
+    return report;
+}
+//# sourceMappingURL=official-subagent-helper-policy.js.map

package/dist/core/codex-app.js

@@ -809,8 +809,6 @@ async function codexFastModeConfigStatus(opts = {}) {
         blockers.push('user.fast_mode.visible_missing');
     if (!/(^|\n)\s*enabled\s*=\s*true\s*(?:#.*)?(?=\n|$)/.test(fastMode))
         blockers.push('user.fast_mode.enabled_missing');
-    if (!/(^|\n)\s*default_profile\s*=\s*"sks-fast-high"\s*(?:#.*)?(?=\n|$)/.test(fastMode))
-        blockers.push('user.fast_mode.default_profile_missing');
     return {
         ok: blockers.length === 0,
         checked: true,

package/dist/core/commands/fast-mode-command.js

@@ -62,7 +62,7 @@ export async function fastModeCommand(args = []) {
     else if (action === 'clear')
         console.log(`Cleared: ${removed ? 'yes' : 'already default'}`);
     else if (!preference)
-        console.log('Preference: implicit fast');
+        console.log('Preference: implicit standard');
     console.log('Dollar: $Fast-On | $Fast-Off | $Fast-Mode');
     return result;
 }