sneakoscope 2.0.16 → 2.0.18

package/README.md

@@ -16,43 +16,34 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## Current Release
 
-SKS **2.0.16** is the real parallelism closure release. It proves Naruto/agent runtime concurrency with PID, launch overlap, wall-clock speedup, active/headless worker, model-call, worktree allocation, and incremental Zellij telemetry evidence while keeping Naruto as the execution SSOT.
+SKS **2.0.18** is the Codex 0.138 integration release: capability artifacts, Desktop `/app` handoff, plugin JSON inventory, image saved-path contracts, model-advertised effort order, account usage budget policy, and startup doctor checks.
 
 What changed:
 
-- Zellij slot panes distinguish `slot_status_renderer` panes from Codex worker panes, and the first visible worker now stacks downward below the `SLOTS` anchor with real geometry proof available under `real-check`.
-- Naruto allocation owners now flow into work graph items, scheduler slices, queue ownership, and worker runtime proof; inactive owners are rebalanced and active write conflicts stay out of concurrent execution.
-- Naruto active-pool checks now exercise actual child-worker spawn/result collection paths while production source-of-truth stays with the agent orchestrator scheduler.
-- Worktree candidate output requires GPT Final approval before apply; GPT `modified` output replaces candidate patches and GPT `rejected` blocks apply.
-- Visible Zellij reservations are capped before pane launch so concurrent worker starts cannot over-open the right column.
-- Git worktree integration now proves the primary repo receives validated worktree diffs, with rollback hash evidence recorded around the apply step.
-- Agent role config repair detects stale generated role files and rewrites structured GPT-5.5-compatible configs atomically.
-- Release gates now include slot-only UI, compact slot renderer, headless overflow, role-config repair, worktree primary-runtime, real active-pool, extreme real parallelism, and real right-column geometry checks.
-- Release audit, dynamic selection, and stamp hashing use `release-gates.v2.json` as the manifest source of truth.
-- Git capability checks detect repo roots, Git dirs, worktree support, and safe cache roots while blocking in-repo worktree roots unless `SKS_ALLOW_IN_REPO_WORKTREES=1` is explicit.
-- Worker worktree allocation creates isolated branches/paths under `$SKS_WORKTREE_ROOT`, `$XDG_CACHE_HOME/sks/worktrees`, or `~/.cache/sks/worktrees`; main checkouts stay untouched until integration.
-- Product Design plugin readiness now checks both local and remote Codex App catalogs, auto-installs the remote plugin when needed, and records the installed/enabled skill surface.
-- UI/design/PPT runtime routes prefer Product Design for research, ideation, audit, design QA, prototype, URL-to-code, image-to-code, share, and user-context steps.
-- Naruto read-only runs force write mode off, propagate no-patch reasons through worker proof, and skip changed-file lease checks when no write-capable patch envelope exists.
-- `codex-sdk` is the default native agent backend for Team, QA, Research, Naruto, MAD-SKS, and direct agent runs, with every runtime task entering through `runCodexTask`.
-- Codex App UI snapshot, preservation, clobber guard, and doctor repair checks protect host-owned Fast UI/profile settings around `sks --mad`.
-- Provider context resolves `openai`, `codex-lb`, and `codex-app` with badge/fallback surfaces while avoiding private Codex App UI mutation.
-- UltraRouter writes `ultra-router-proof.json` decisions with tier, scores, hard filters, cache state, and cheapest-good-enough profile selection.
-- Reliability Shield writes `codex-reliability-shield.json` for empty-result retry, stream-idle blocking, tool-result repair, and no-CoT keepalive heartbeats.
-- Raw `codex exec` execution is removed from runtime fallback paths; explicit legacy requests are blocked with `legacy_codex_exec_runtime_removed`.
-- SDK runs write `codex-control-proof.json`, `codex-thread-registry.json`, `codex-sdk-events.jsonl`, and schema-validated worker results.
-- Zellij proof now links `pane_id`, `slot_id`, `generation_index`, `session_id`, `sdk_thread_id`, provider, and `service_tier`.
-- Production runtime scripts are TypeScript source under `src/scripts` and build to `dist/scripts`; Python remains optional diagnostics under `pytools`.
-- Release gates include `codex-control:*`, `ultra-router:*`, `codex-sdk:*`, Codex App Fast UI preservation, provider badges, Zellij spawn-on-demand, slot/pane binding, release truth, and real smoke checks.
-- Research synthesis is now evidence-bound in non-mock runs; deterministic report generation is mock/fallback only.
-- Research quality checks reject repeated paragraphs, template-like prose, low source density, low claim density, and thin implementation sections.
-- Research handoffs now include context, key claims, evidence summary, blueprint sections, parallel work items, acceptance tests, rollback, and source appendix for `$Team` or `$Naruto`.
+- `sks doctor` now reports Codex 0.138 feature readiness, plugin JSON inventory, candidate-only remote MCP servers, unavailable app templates, and repairable plugin discovery cache state.
+- QA-LOOP can write a Codex Desktop `/app` handoff artifact with `--app-handoff` or require it with `--app-handoff-required`; this never substitutes for Codex Chrome Extension web UI evidence.
+- Zellij slot panes and the right-column anchor surface pending QA `/app` handoffs so desktop review is visible during long native-agent runs.
+- Codex plugin detail JSON is normalized into `.sneakoscope/codex-plugin-inventory.json`, and plugin-provided remote MCP servers remain candidate-only until explicitly enabled under DB/Mad-DB safety policy.
+- Imagegen and QA image flows write `image-artifact-path-contract.json` with exact saved file paths and follow-up edit hints.
+- Effort routing now understands the fallback order `minimal < low < medium < high < xhigh`, records model capability, and escalates QA effort after repeated failures.
+- Codex account token usage can be recorded from an app-server usage endpoint, and QA budget policy reduces remote concurrency near limits while preserving GPT final review.
+- Naruto final pass status now depends on the parallel runtime proof, and Mad-DB post-tool lifecycle recording handles MCP `isError` failures.
 
 Quick checks:
 
 ```bash
 npm run typecheck
 npm run build
+npm run codex:0138-capability
+npm run codex-sdk:version-compat
+npm run codex-app:handoff
+npm run codex-plugin:inventory
+npm run qa-loop:app-handoff
+npm run image:artifact-path-contract
+npm run codex:effort-order
+npm run codex:account-usage
+npm run codex:0138-doctor
+npm run doctor:codex-0138-fix
 npm run codex-control:capability
 npm run codex-control:structured-output
 npm run codex-control:event-stream-ledger
@@ -613,7 +604,9 @@ SKS_HERMES=1 sks status --json
 
 Use these inside Codex App or another agent prompt. They are prompt commands, not terminal commands.
 
-Common prompts: `$Team`, `$From-Chat-IMG`, `$with-local-llm-on`, `$with-local-llm-off`, `$DFix`, `$Answer`, `$SKS`, `$QA-LOOP`, `$PPT`, `$Computer-Use`/`$CU`, `$Goal`, `$Research`, `$AutoResearch`, `$DB`, `$MAD-SKS`, `$GX`, `$Wiki`, and `$Help`.
+Common prompts: `$Team`, `$From-Chat-IMG`, `$with-local-llm-on`, `$with-local-llm-off`, `$DFix`, `$Answer`, `$SKS`, `$QA-LOOP`, `$PPT`, `$Computer-Use`/`$CU`, `$Goal`, `$Research`, `$AutoResearch`, `$DB`, `$MAD-SKS`, `$MAD-DB`, `$GX`, `$Wiki`, and `$Help`.
+
+`$MAD-DB` is the prompt-visible Mad-DB alias for one-cycle DB break-glass work. It maps to the same guarded MAD-SKS permission route, while the terminal lifecycle remains `sks mad-db status|enable|revoke`; it is not a permanent DB unlock and catastrophic DB safeguards remain active.
 
 ## Common Workflows
 
@@ -759,7 +752,7 @@ npm run release:check
 npm run publish:dry
 ```
 
-`release:check` runs the change-aware affected release gate for ordinary local checks. Publish readiness uses `release:check:full`, which runs the full release DAG and writes a source digest stamp under `.sneakoscope/reports/` so publish commands can verify the same source/dist state. The DAG preserves the 1.18 baseline gates and adds Codex 0.136 compatibility, inherited Codex 0.135/0.134 runner truth, patch swarm runtime truth, transaction journaling, serial conflict rebase, strict strategy-to-patch proof, rollback command proof, Native CLI Session Swarm 5/10/20-process proof, Real Worker Backend Router proof, Codex child overlap proof, model-authored patch-envelope separation, Zellij layout/pane/screen/socket-dir proof, no-subagent-scaling proof, Fast mode default/worker/Codex/MAD propagation proof, Appshots attachment provenance, MCP runtime overlap evidence, task graph expansion, schema-bound follow-up work, actual Agent/Team/Research/QA route blackboxes, scheduler proof hardening, Source Intelligence propagation, Goal mode propagation checks, slot telemetry, update notice, MAD-DB, and Naruto SSOT gates. Broader live gates remain explicit scripts such as `release:real-check`; real Codex patch smoke, real Codex parallel worker proof, and real Zellij proof are optional unless their `SKS_REQUIRE_REAL_*` or `SKS_REQUIRE_ZELLIJ=1` environment variables are set. Generate the human-readable registry with `sks features inventory --write-docs`. Plain `npm publish` uses the `latest` dist-tag. npm's `prepublishOnly` and `npm run publish:dry` both run `release:check:full`, verify the fresh stamp, and then run provenance/registry checks before the real or dry-run publish step.
+`release:check` runs the change-aware affected release gate for ordinary local checks. Publish readiness uses `release:check:full`, which runs the full release DAG and writes a source digest stamp under `.sneakoscope/reports/` so publish commands can verify the same source/dist state. The DAG preserves the 1.18 baseline gates and adds Codex 0.136 compatibility, inherited Codex 0.135/0.134 runner truth, patch swarm runtime truth, transaction journaling, serial conflict rebase, strict strategy-to-patch proof, rollback command proof, Native CLI Session Swarm 5/10/20-process proof, Real Worker Backend Router proof, Codex child overlap proof, model-authored patch-envelope separation, Zellij layout/pane/screen/socket-dir proof, no-subagent-scaling proof, Fast mode default/worker/Codex/MAD propagation proof, Appshots attachment provenance, MCP runtime overlap evidence, task graph expansion, schema-bound follow-up work, actual Agent/Team/Research/QA route blackboxes, scheduler proof hardening, Source Intelligence propagation, Goal mode propagation checks, slot telemetry, update notice, MAD-DB, and Naruto SSOT gates. Broader live gates remain explicit scripts such as `release:real-check`; real Codex patch smoke, real Codex parallel worker proof, and real Zellij proof are optional unless their `SKS_REQUIRE_REAL_*` or `SKS_REQUIRE_ZELLIJ=1` environment variables are set. Generate the human-readable registry with `sks features inventory --write-docs`. Plain `npm publish` uses the `latest` dist-tag. `npm run publish:dry` runs `release:check:full`, verifies the fresh stamp, and then performs provenance/registry and npm dry-run checks. npm's `prepublishOnly` uses `prepublish-release-check-or-fast` to accept that current stamp before the real publish; if the stamp is missing or stale, it runs `release:check:full` once before continuing.
 
 Version bumps are manual. Run `sks versioning bump` only when preparing release metadata; SKS will not create `.git/hooks/pre-commit` or auto-bump during ordinary commits.
 

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "2.0.16"
+version = "2.0.18"
 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 2.0.16"),
+        Some("--version") => println!("sks-rs 2.0.18"),
         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": "2.0.16",
-  "source_digest": "cafc32cad87d3b6c7aeb0ec0e8e56258f830b35e71fd919440a8c1b95b78432a",
-  "source_file_count": 2187,
-  "built_at_source_time": 1780927200051
+  "package_version": "2.0.18",
+  "source_digest": "3c246288e22bf5f29b5ba20a2a05b3f15a6afb9e6d680c531f7e78ef996c8c33",
+  "source_file_count": 2238,
+  "built_at_source_time": 1780992531184
 }

package/dist/bin/sks.js

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

package/dist/cli/command-registry.js

@@ -119,7 +119,7 @@ export const COMMANDS = {
     commit: entry('stable', 'Create a simple git commit', 'dist/commands/commit.js', directCommand(() => import('../commands/commit.js'), 'dist/commands/commit.js')),
     'commit-and-push': entry('stable', 'Create a simple git commit and push', 'dist/commands/commit-and-push.js', directCommand(() => import('../commands/commit-and-push.js'), 'dist/commands/commit-and-push.js')),
     dfix: entry('stable', 'Run DFix diagnose/plan/patch/verify loop', 'dist/core/commands/dfix-command.js', commandArgsCommand(() => import('../core/commands/dfix-command.js'), 'dfixCommand', 'dist/core/commands/dfix-command.js')),
-    team: entry('beta', 'Deprecated Team alias; create redirects to Naruto, observe legacy Team missions', 'dist/core/commands/team-command.js', argsCommand(() => import('../core/commands/team-command.js'), 'team', 'dist/core/commands/team-command.js')),
+    team: entry('beta', 'Deprecated alias. New execution redirects to Naruto; legacy observe/watch remains.', 'dist/core/commands/team-command.js', argsCommand(() => import('../core/commands/team-command.js'), 'team', 'dist/core/commands/team-command.js')),
     agent: entry('beta', 'Run native multi-session agent missions', 'dist/core/commands/agent-command.js', argsCommand(() => import('../core/commands/agent-command.js'), 'agentCommand', 'dist/core/commands/agent-command.js')),
     'with-local-llm': entry('beta', 'Enable or inspect local Ollama worker backend', 'dist/core/commands/local-model-command.js', argsCommand(() => import('../core/commands/local-model-command.js'), 'localModelCommand', 'dist/core/commands/local-model-command.js')),
     naruto: entry('labs', 'Run $Naruto shadow-clone swarm (up to 100 parallel sessions)', 'dist/core/commands/naruto-command.js', argsCommand(() => import('../core/commands/naruto-command.js'), 'narutoCommand', 'dist/core/commands/naruto-command.js')),

package/dist/commands/doctor.js

@@ -19,6 +19,10 @@ import { repairCodexAppFastUi } from '../core/codex-app/codex-app-fast-ui-repair
 import { resolveProviderContext } from '../core/provider/provider-context.js';
 import { readLocalModelConfig } from '../core/agents/ollama-worker-config.js';
 import { repairAgentRoleConfigs } from '../core/agents/agent-role-config.js';
+import { writeCodex0138CapabilityArtifacts } from '../core/codex-control/codex-0138-capability.js';
+import { runCodex0138Doctor } from '../core/doctor/codex-0138-doctor.js';
+import { writeCodexPluginInventoryArtifacts, pluginAppTemplatePolicy } from '../core/codex-plugins/codex-plugin-json.js';
+import { writeMcpPluginInventoryArtifacts } from '../core/mcp/mcp-plugin-inventory.js';
 export async function run(_command, args = []) {
     const doctorFix = flag(args, '--fix');
     let setupRepair = null;
@@ -167,6 +171,13 @@ export async function run(_command, args = []) {
         : null;
     const { detectImagegenCapability } = await import('../core/imagegen/imagegen-capability.js');
     const imagegen = await detectImagegenCapability({ codexBin: codexBin || undefined }).catch((err) => ({ ok: false, error: err.message, auth_readiness: null }));
+    const codex0138Capability = await writeCodex0138CapabilityArtifacts(root, { codexBin: codexBin || null }).catch((err) => ({ error: err?.message || String(err), report: null }));
+    const codex0138Doctor = await runCodex0138Doctor(root, { fix: doctorFix }).catch((err) => ({ schema: 'sks.codex-0138-doctor.v1', ok: false, error: err?.message || String(err), blockers: ['codex_0138_doctor_exception'], warnings: [] }));
+    const pluginInventory = await writeCodexPluginInventoryArtifacts(root).catch((err) => ({ error: err?.message || String(err), report: null, artifact: null }));
+    const pluginPolicy = pluginInventory?.report ? pluginAppTemplatePolicy(pluginInventory.report) : null;
+    const mcpPluginInventory = pluginInventory?.report
+        ? await writeMcpPluginInventoryArtifacts(root, { inventory: pluginInventory.report }).catch((err) => ({ error: err?.message || String(err), candidates: null }))
+        : null;
     const pkgBytes = await dirSize(root).catch(() => 0);
     const ready = await writeDoctorReadinessMatrix(root, {
         codex,
@@ -180,10 +191,14 @@ export async function run(_command, args = []) {
         agent_role_config: agentRoleConfigRepair,
         repair: configRepair,
         codex_app_ui: codexAppUi,
+        codex_0138_doctor: codex0138Doctor,
+        codex_plugin_inventory: pluginInventory?.report || null,
+        codex_plugin_app_template_policy: pluginPolicy,
         require_codex_cli_config_load: flag(args, '--fix') || flag(args, '--require-actual-codex'),
         operator_actions: [
             ...(codexConfig.operator_actions || []),
-            ...(configRepair?.operator_actions || [])
+            ...(configRepair?.operator_actions || []),
+            ...(pluginPolicy?.doctor_warnings || [])
         ]
     });
     const zellijReadiness = buildZellijReadiness(root, zellij, ready);
@@ -211,6 +226,13 @@ export async function run(_command, args = []) {
             auth_readiness: imagegen.auth_readiness || null,
             codex_app_builtin_available: imagegen.codex_app?.available === true
         },
+        codex_0138: {
+            capability: codex0138Capability.report || null,
+            doctor: codex0138Doctor,
+            plugins: pluginInventory?.report || null,
+            plugin_app_template_policy: pluginPolicy,
+            mcp_plugin_inventory: mcpPluginInventory?.candidates || null
+        },
         ready,
         sneakoscope: { ok: await exists(`${root}/.sneakoscope`) },
         package: { bytes: pkgBytes, human: formatBytes(pkgBytes) },
@@ -262,6 +284,22 @@ export async function run(_command, args = []) {
                 console.log(`  - ${action}`);
         }
     }
+    const codex0138 = codex0138Capability.report || {};
+    console.log('Codex 0.138 features:');
+    console.log(`  /app handoff: ${codex0138.supports_app_handoff ? 'ok' : 'unavailable'}`);
+    console.log(`  plugin JSON: ${codex0138.supports_plugin_json ? 'ok' : 'unavailable'}`);
+    console.log(`  image path exposure: ${codex0138.supports_image_path_exposure ? 'ok' : 'unavailable'}`);
+    console.log(`  OAuth MCP pre-refresh: ${codex0138.supports_oauth_mcp_prerefresh ? 'ok' : 'unavailable'}`);
+    const plugins = pluginInventory?.report?.plugins || [];
+    const remoteMcpCount = plugins.flatMap((plugin) => plugin.remote_mcp_servers || []).length;
+    const unavailableTemplates = pluginPolicy?.unavailable_app_templates?.length || 0;
+    console.log(`Codex plugins: ${pluginInventory?.report ? 'ok' : 'warning'}`);
+    console.log(`  Remote MCP servers: ${remoteMcpCount} candidates`);
+    console.log(`  Unavailable app templates: ${unavailableTemplates}`);
+    for (const warning of pluginPolicy?.doctor_warnings || [])
+        console.log(`  warning: ${warning}`);
+    if (codex0138Doctor?.fixed?.length)
+        console.log(`  doctor --fix repaired: ${codex0138Doctor.fixed.join(', ')}`);
     console.log(`codex-lb:  ${codexLb.ok ? 'ok' : `warning ${codexLb.circuit?.state || 'unknown'}`}`);
     if (localModel) {
         console.log('Local LLM:');

package/dist/commands/proof.js

@@ -8,10 +8,20 @@ import { writeRouteCompletionProof } from '../core/proof/route-adapter.js';
 import { finalizeRouteWithProof } from '../core/proof/route-finalizer.js';
 import { renderProofMarkdown, writeCompletionProof } from '../core/proof/proof-writer.js';
 import { validateCompletionProof } from '../core/proof/validation.js';
+import { buildRuntimeProofSummary, renderRuntimeProofSummary } from '../core/agents/runtime-proof-summary.js';
 export async function run(_command, args = []) {
     const root = await projectRoot();
     const action = args[0] || 'show';
     const rest = args.slice(1);
+    if (action === 'latest' && !flag(args, '--completion')) {
+        const runtime = await tryRuntimeProofSummary(root);
+        if (runtime) {
+            if (flag(args, '--json'))
+                return printJson(runtime);
+            console.log(renderRuntimeProofSummary(runtime));
+            return;
+        }
+    }
     if (action === 'show' || action === 'latest') {
         const proof = await withFreshSummaries(root, await readLatestProof(root));
         if (flag(args, '--json') || action === 'latest')
@@ -122,6 +132,17 @@ export async function run(_command, args = []) {
     console.error('Usage: sks proof show|latest|validate|route <mission-id|latest>|finalize <mission-id|latest> [--route route] [--strict] [--mock] [--json]|export --md|repair latest|smoke [--json]');
     process.exitCode = 1;
 }
+async function tryRuntimeProofSummary(root) {
+    try {
+        const summary = await buildRuntimeProofSummary(root, 'latest');
+        if (summary.blockers.includes('parallel_runtime_proof_missing') && summary.blockers.includes('agent_scheduler_state_missing'))
+            return null;
+        return summary;
+    }
+    catch {
+        return null;
+    }
+}
 async function withFreshSummaries(root, proof) {
     const evidence = await collectProofEvidence(root);
     return {

package/dist/commands/zellij-slot-pane.js

@@ -1,4 +1,4 @@
-import { renderZellijSlotPaneFromArtifacts } from '../core/zellij/zellij-slot-pane-renderer.js';
+import { renderZellijSlotPaneFromArtifacts, renderZellijSlotPaneStatusFromArtifacts } from '../core/zellij/zellij-slot-pane-renderer.js';
 export async function run(_command = 'zellij-slot-pane', args = []) {
     const artifactDir = readOption(args, '--artifact-dir', process.cwd()) || process.cwd();
     const artifactRoot = readOption(args, '--artifact-root', artifactDir) || artifactDir;
@@ -9,7 +9,13 @@ export async function run(_command = 'zellij-slot-pane', args = []) {
     const role = readOption(args, '--role', null);
     const mode = readOption(args, '--mode', 'compact-slots');
     const watch = hasFlag(args, '--watch');
+    const json = hasFlag(args, '--json');
     const intervalMs = Math.max(250, Number(readOption(args, '--interval-ms', '1000') || 1000));
+    if (json) {
+        const status = await renderZellijSlotPaneStatusFromArtifacts({ artifactDir, artifactRoot, missionId, slotId, generationIndex });
+        console.log(JSON.stringify(status, null, 2));
+        return;
+    }
     for (;;) {
         const text = await renderZellijSlotPaneFromArtifacts({ artifactDir, artifactRoot, missionId, slotId, generationIndex, backend, role, mode });
         process.stdout.write('\x1Bc' + text + '\n');

package/dist/core/agents/agent-effort-policy.js

@@ -1,3 +1,4 @@
+import { codexModelEffortCapability } from '../codex-control/codex-model-capabilities.js';
 const XHIGH_SIGNAL_RE = /(frontier|autoresearch|novelty|hypothesis|falsif|forensic|from-chat-img|image\s*work\s*order|새로운\s*연구|가설|포렌식)/i;
 const HIGH_SIGNAL_RE = /(database|supabase|sql|migration|security|permission|mad|release|publish|deploy|architecture|policy|schema|hook|rollback|db|보안|배포|마이그레이션|데이터베이스|권한|릴리즈)/i;
 const MEDIUM_SIGNAL_RE = /(tmux|terminal|cli|tool(?:\s|-)?call|router|routing|orchestrat|pipeline|multi[-\s]?session|multi[-\s]?agent|lease|ledger|proof|검증|파이프라인|오케스트레이션|병렬|에이전트)/i;
@@ -26,6 +27,7 @@ export function decideAgentEffort(input = {}) {
         effort = 'high';
         reason = 'implementation_lane_capped_at_high';
     }
+    const modelCapability = codexModelEffortCapability({ defaultEffort: effort });
     return {
         schema: 'sks.agent-effort-decision.v1',
         policy_version: 1,
@@ -33,6 +35,7 @@ export function decideAgentEffort(input = {}) {
         role,
         reasoning_effort: effort,
         model_reasoning_effort: effort,
+        model_effort_capability: modelCapability,
         reasoning_profile: reasoningProfileName(effort),
         service_tier: 'fast',
         reason,
@@ -73,6 +76,7 @@ export function decideNarutoCloneEffort(input = {}) {
     const writes = !readonly || /write|edit|route-local|workspace|patch|integrat/i.test(writePolicy) || hasActionTool;
     const toolUse = writes || NARUTO_ACTION_TOOL_RE.test(prompt);
     const effort = toolUse ? 'medium' : 'low';
+    const modelCapability = codexModelEffortCapability({ defaultEffort: effort });
     return {
         schema: 'sks.agent-effort-decision.v1',
         policy_version: 1,
@@ -80,6 +84,7 @@ export function decideNarutoCloneEffort(input = {}) {
         role,
         reasoning_effort: effort,
         model_reasoning_effort: effort,
+        model_effort_capability: modelCapability,
         reasoning_profile: reasoningProfileName(effort),
         service_tier: 'fast',
         reason: toolUse ? 'naruto_tool_use_medium' : 'naruto_simple_no_tool_low',
@@ -107,7 +112,8 @@ export function buildAgentEffortPolicy(roster = {}) {
         policy_version: 1,
         dynamic: true,
         service_tier: 'fast',
-        allowed_efforts: ['low', 'medium', 'high', 'xhigh'],
+        allowed_efforts: codexModelEffortCapability().advertised_efforts,
+        model_effort_capability: codexModelEffortCapability(),
         max_agents: roster.max_agents || 20,
         agent_count: roster.agent_count || decisions.length,
         concurrency: roster.concurrency || decisions.length,

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

@@ -476,7 +476,9 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         targetActiveSlots,
         visiblePanes: visualLaneCount,
         expectedWorkerRuntimeMs: targetActiveSlots >= 10 ? 8000 : targetActiveSlots >= 2 ? 2000 : 25,
-        minActiveWorkers: Math.min(targetActiveSlots, desiredWorkItemCount)
+        minActiveWorkers: Math.min(targetActiveSlots, desiredWorkItemCount),
+        proofMode: opts.mock === true ? 'mock-process' : 'production',
+        requireWorkerPids: opts.nativeCliSwarm !== false && targetActiveSlots >= 16
     });
     const results = scheduler.results;
     const nativeCliSessionProof = await writeNativeCliSessionProof(ledgerRoot, {

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

@@ -21,6 +21,8 @@ export async function runAgentScheduler(input) {
     const active = new Map();
     const results = [];
     const schedulerStartedAt = Date.now();
+    let lastUtilizationUpdateMs = schedulerStartedAt;
+    let activeSlotTimeMs = 0;
     let batchCounter = 0;
     let batchLaunchSpanTotalMs = 0;
     let batchDispatchInProgress = false;
@@ -43,6 +45,7 @@ export async function runAgentScheduler(input) {
         if (!entry)
             continue;
         const activeCountBeforeClose = active.size;
+        accumulateActiveSlotTime();
         active.delete(settled.session_id);
         const resultStatus = settled.result?.status === 'done' ? 'completed' : settled.result?.status === 'blocked' ? 'blocked' : 'failed';
         completeWorkItem(queue, entry.work_item_id, settled.session_id, resultStatus, settled.error || null);
@@ -70,6 +73,7 @@ export async function runAgentScheduler(input) {
         const pendingAfterClose = pendingWorkItems(queue).length;
         if (pendingAfterClose > 0)
             state.expected_backfill_count += 1;
+        updateUtilizationMetrics();
         await writeAll(input.root, state, slots, queue, active, {
             event_type: 'session_completed',
             session_id: settled.session_id,
@@ -85,6 +89,7 @@ export async function runAgentScheduler(input) {
             closed_at_ms: Date.now()
         } : null);
     }
+    updateUtilizationMetrics();
     state.status = 'draining';
     await writeAll(input.root, state, slots, queue, active, { event_type: 'scheduler_draining' }, input.onSchedulerEvent);
     slots = closeWorkerSlotsAfterDrain(slots);
@@ -204,6 +209,7 @@ export async function runAgentScheduler(input) {
                     error: err instanceof Error ? err.message : String(err),
                     terminal_close_report_path: path.join(generation.artifact_dir, 'agent-terminal-close-report.json')
                 }));
+                accumulateActiveSlotTime();
                 active.set(generation.session_id, { slot_id: slot.slot_id, work_item_id: workItem.id, session_id: generation.session_id, promise });
             }
             await appendAgentWorkQueueEvent(input.root, 'batch_work_items_dispatched', {
@@ -317,11 +323,18 @@ export async function runAgentScheduler(input) {
         return launches;
     }
     function updateUtilizationMetrics() {
+        accumulateActiveSlotTime();
         state.wall_time_ms = Math.max(0, Date.now() - schedulerStartedAt);
-        state.active_slot_time_ms = Math.max(state.active_slot_time_ms, state.completed_count * state.wall_time_ms);
+        state.active_slot_time_ms = activeSlotTimeMs;
         const denominator = Math.max(1, state.wall_time_ms * targetActiveSlots);
         state.scheduler_utilization = Number(Math.min(1, state.active_slot_time_ms / denominator).toFixed(3));
     }
+    function accumulateActiveSlotTime() {
+        const now = Date.now();
+        const delta = Math.max(0, now - lastUtilizationUpdateMs);
+        activeSlotTimeMs += active.size * delta;
+        lastUtilizationUpdateMs = now;
+    }
 }
 export function normalizeTargetActiveSlots(value, maxActiveSlots = MAX_AGENT_COUNT) {
     const cap = Number.isFinite(Number(maxActiveSlots)) && Number(maxActiveSlots) >= 1 ? Math.floor(Number(maxActiveSlots)) : MAX_AGENT_COUNT;

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

@@ -8,7 +8,7 @@ import { closeWorkerPane, openWorkerPane } from '../zellij/zellij-worker-pane-ma
 import { closeWorkerInRightColumn, recordHeadlessWorkerInRightColumn } from '../zellij/zellij-right-column-manager.js';
 import { resolveProviderContext } from '../provider/provider-context.js';
 import { buildZellijSlotPaneCommand } from '../zellij/zellij-slot-pane-renderer.js';
-import { resolveZellijUiMode } from '../zellij/zellij-ui-mode.js';
+import { resolveZellijWorkerPaneUiMode } from '../zellij/zellij-ui-mode.js';
 import { appendZellijSlotTelemetry } from '../zellij/zellij-slot-telemetry.js';
 import { appendParallelRuntimeEvent } from './parallel-runtime-proof.js';
 export const NATIVE_CLI_SESSION_SWARM_SCHEMA = 'sks.agent-native-cli-session-swarm.v1';
@@ -278,7 +278,8 @@ class NativeCliSessionSwarmRecorder {
             route: this.input.route,
             serviceTier: this.input.fastModePolicy.service_tier
         });
-        const uiMode = resolveZellijUiMode(Array.isArray(input.ctx.opts.args) ? input.ctx.opts.args : [], process.env);
+        const uiMode = resolveZellijWorkerPaneUiMode(Array.isArray(input.ctx.opts.args) ? input.ctx.opts.args : [], process.env);
+        const liveWorkerPane = uiMode !== 'compact-slots';
         const workerEnv = {
             ...(input.ctx.opts.env || {}),
             ...fastModeEnv(this.input.fastModePolicy),
@@ -300,7 +301,7 @@ class NativeCliSessionSwarmRecorder {
             artifacts: [path.join(input.workerDirRel, 'worker-intake.json'), input.heartbeatRel, input.resultRel],
             logTail: `zellij=${sessionName}`
         });
-        const workerCommand = uiMode === 'full-debug'
+        const workerCommand = liveWorkerPane
             ? buildPaneWorkerCommand({
                 args: input.args,
                 stdoutPath: path.join(this.root, input.stdoutRel),
@@ -332,7 +333,7 @@ class NativeCliSessionSwarmRecorder {
                 mode: uiMode,
                 watch: true
             });
-        const processRun = uiMode === 'full-debug'
+        const processRun = liveWorkerPane
             ? null
             : await this.spawnCompactSlotWorkerProcess({
                 args: input.args,
@@ -405,7 +406,7 @@ class NativeCliSessionSwarmRecorder {
         const zellijRequired = process.env.SKS_REQUIRE_ZELLIJ === '1';
         const launchBlockers = zellijRequired ? paneRecord.blockers || [] : [];
         const launchWarnings = zellijRequired ? [] : paneRecord.blockers || [];
-        input.record.command_line = ['zellij', '--session', sessionName, 'action', 'new-pane', '--direction', paneRecord.direction_applied, '--name', paneRecord.pane_name, '--', 'sh', '-lc', uiMode === 'full-debug' ? '<native-cli-worker-command>' : '<zellij-slot-pane-renderer-command>'];
+        input.record.command_line = ['zellij', '--session', sessionName, 'action', 'new-pane', '--direction', paneRecord.direction_applied, '--name', paneRecord.pane_name, '--', 'sh', '-lc', liveWorkerPane ? '<native-cli-worker-command>' : '<zellij-slot-pane-renderer-command>'];
         input.record.zellij_session_name = sessionName;
         input.record.zellij_pane_id = paneRecord.pane_id || null;
         input.record.zellij_pane_id_source = paneRecord.pane_id_source;
@@ -419,7 +420,7 @@ class NativeCliSessionSwarmRecorder {
         input.record.provider_context = paneRecord.provider_context;
         input.record.worktree = worktree;
         input.record.zellij_ui_mode = uiMode;
-        input.record.slot_visualization = uiMode === 'full-debug' ? 'worker-command-pane' : 'zellij-slot-pane-renderer';
+        input.record.slot_visualization = liveWorkerPane ? 'worker-command-pane' : 'zellij-slot-pane-renderer';
         input.record.status = launchBlockers.length ? 'failed' : 'running';
         input.record.blockers = launchBlockers;
         input.record.warnings = [...(input.record.warnings || []), ...launchWarnings];
@@ -741,7 +742,10 @@ export function buildPaneWorkerCommand(input) {
     const holdMs = Math.max(0, Number(process.env.SKS_ZELLIJ_WORKER_PANE_HOLD_MS || 1500));
     const hold = holdMs > 0 ? `sleep ${shellQuote(String(Math.min(30, holdMs / 1000)))}` : ':';
     const header = input.header ? `printf '%s\\n' ${shellQuote(input.header)} | tee -a ${shellQuote(input.stdoutPath)};` : '';
-    return `${envPrefix.join(' ')} ${header} ${command} >> ${shellQuote(input.stdoutPath)} 2>> ${shellQuote(input.stderrPath)}; code=$?; ${heartbeat}; ${hold}; exit $code`.trim();
+    const exitPath = `${input.heartbeatPath}.exit`;
+    const visibleCommand = `(${command}; printf '%s' "$?" > ${shellQuote(exitPath)}) 2>&1 | tee -a ${shellQuote(input.stdoutPath)}`;
+    const readExit = `code=$(cat ${shellQuote(exitPath)} 2>/dev/null || printf '1'); rm -f ${shellQuote(exitPath)}`;
+    return `${envPrefix.join(' ')} ${header} ${visibleCommand}; ${readExit}; ${heartbeat}; ${hold}; exit $code`.trim();
 }
 function buildPaneWorkerHeader(input) {
     return [

package/dist/core/agents/native-cli-worker.js

@@ -126,18 +126,33 @@ export async function runNativeCliWorker(input = {}) {
     });
     await writeJsonAtomic(path.join(workerDir, 'worker-recursion-guard.json'), guard);
     let noPatchReason = null;
-    const routed = await runNativeWorkerBackendRouter({
+    const progressTelemetry = startWorkerProgressTelemetry({
         agentRoot,
-        workerDirRel,
-        resultRel,
-        patchRel,
+        heartbeatRel,
+        intake,
         agent,
         slice,
-        intake: { ...intake, ...input },
         backend,
-        fastModePolicy: policy,
-        guard
+        serviceTier: policy.service_tier
     });
+    let routed;
+    try {
+        routed = await runNativeWorkerBackendRouter({
+            agentRoot,
+            workerDirRel,
+            resultRel,
+            patchRel,
+            agent,
+            slice,
+            intake: { ...intake, ...input },
+            backend,
+            fastModePolicy: policy,
+            guard
+        });
+    }
+    finally {
+        progressTelemetry.stop();
+    }
     const patchEnvelopes = routed.patchEnvelopes;
     if (patchEnvelopes.length) {
         await writeJsonAtomic(path.resolve(agentRoot, patchRel), {
@@ -330,6 +345,39 @@ export async function runNativeCliWorker(input = {}) {
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function startWorkerProgressTelemetry(input) {
+    const parsed = Number(process.env.SKS_ZELLIJ_WORKER_PROGRESS_MS || 2000);
+    const intervalMs = Math.max(500, Number.isFinite(parsed) ? Math.floor(parsed) : 2000);
+    let tick = 0;
+    const timer = setInterval(() => {
+        tick += 1;
+        const progress = { done: tick, total: 0, label: 'backend running' };
+        appendJsonl(path.resolve(input.agentRoot, input.heartbeatRel), {
+            schema: 'sks.native-cli-worker-heartbeat.v1',
+            ts: nowIso(),
+            event: 'progress',
+            pid: process.pid,
+            session_id: input.agent.session_id,
+            slot_id: input.agent.slot_id || null,
+            generation_index: input.agent.generation_index || null,
+            progress
+        }).catch(() => undefined);
+        workerTelemetry(input.agentRoot, input.intake, input.agent, input.slice, {
+            eventType: 'task_progress',
+            status: 'running',
+            backend: input.backend,
+            serviceTier: input.serviceTier,
+            artifacts: [input.heartbeatRel],
+            progress,
+            logTail: `backend running ${tick}`
+        }).catch(() => undefined);
+    }, intervalMs);
+    return {
+        stop() {
+            clearInterval(timer);
+        }
+    };
+}
 function parseNativeCliWorkerArgs(args) {
     return {
         intake: readOption(args, '--intake', ''),
@@ -389,6 +437,7 @@ async function workerTelemetry(agentRoot, intake, agent, slice, input) {
         worktree_path: agent.worktree?.path || slice.worktree?.path || intake.worktree?.path || null,
         task_title: String(slice.description || slice.title || slice.id || 'worker task'),
         current_file: firstString([slice.write_paths?.[0], slice.readonly_paths?.[0], slice.input_files?.[0]]) || null,
+        ...(input.progress ? { progress: input.progress } : {}),
         artifact_paths: input.artifacts || [],
         log_tail: input.logTail || '',
         blockers: input.blockers || []