sneakoscope 6.1.2 → 6.2.0

package/dist/core/managed-assets/managed-assets-manifest.js

@@ -1,6 +1,7 @@
 import { sha256 } from '../fsx.js';
+import { subagentModelProfile } from '../subagents/model-policy.js';
 export const MANAGED_ASSET_SCHEMA_VERSION = 1;
-export const MANAGED_ASSET_VERSION = '6.1.2';
+export const MANAGED_ASSET_VERSION = '6.2.0';
 export const MANAGED_ASSET_MARKER = 'SKS-MANAGED-ASSET';
 export const MANAGED_OFFICIAL_SUBAGENT_MARKER = 'SKS-MANAGED-OFFICIAL-SUBAGENT';
 export const MANAGED_AGENT_ROLES = Object.freeze([
@@ -25,15 +26,15 @@ export const MANAGED_OFFICIAL_SUBAGENT_ROLES = Object.freeze([
         filename: 'worker.toml',
         aliases: ['worker'],
         codexName: 'worker',
-        description: 'Execution-focused subagent for clear, bounded, repeatable work with an explicit done condition.',
-        model: 'gpt-5.6-luna',
-        keywords: ['bounded', 'mechanical', 'repeatable', 'rename', 'format', 'copy', 'fixture'],
+        description: 'Luna Max execution subagent only for tiny, short-context, mechanical work with an explicit done condition.',
+        policy: 'luna_max_mechanical',
+        keywords: ['tiny', 'short context', 'single file', 'mechanical', 'repeatable', 'exact rename', 'format only', 'typo'],
         nicknames: ['Kite', 'Moss', 'Pico', 'Reed', 'Vale', 'Wren'],
         instructions: `You are a bounded execution subagent.
 
 Work only on the exact slice assigned by the parent agent.
 Do not redesign the task, expand scope, or spawn another subagent.
-Prefer clear, mechanical, repeatable execution.
+Use this role only when the context is short and the work is tiny, mechanical, repeatable, and free of judgment, exploration, debugging, or design.
 Respect the parent session's sandbox and approval mode.
 When writing, touch only the assigned files or paths.
 Run only the verification directly relevant to your slice.
@@ -49,14 +50,14 @@ Do not claim success without direct evidence.`
         filename: 'implementation-specialist.toml',
         aliases: ['implementation-specialist', 'core-implementer'],
         codexName: 'implementation_specialist',
-        description: 'Sol implementation specialist for bounded backend, core, API, lifecycle, and cross-file refactors with disjoint ownership.',
-        model: 'gpt-5.6-sol',
-        keywords: ['implementation', 'backend', 'core', 'api', 'lifecycle fix', 'cross-file refactor', 'complex change', '구현', '백엔드', '핵심 로직'],
+        description: 'Sol High implementation specialist for ordinary backend, core, API, lifecycle, and cross-file coding with disjoint ownership.',
+        policy: 'sol_high_implementation',
+        keywords: ['implementation', 'backend', 'core', 'api', 'lifecycle implementation', 'cross-file coding', 'feature change', '구현', '백엔드', '핵심 로직'],
         nicknames: ['Builder', 'Forge', 'Mason', 'Rivet'],
         instructions: `You are the bounded complex implementation specialist.
 
 Own only the disjoint files and acceptance criteria assigned by the parent.
-Use this role for non-mechanical backend, core, API, lifecycle, and cross-file implementation.
+Use this role for ordinary non-mechanical backend, core, API, lifecycle, and cross-file implementation. Escalate review, debugging, planning, architecture, security, release, and ambiguous work to a Sol Max specialist.
 Do not redesign unrelated architecture or integrate sibling work.
 Make the smallest defensible change, run focused verification, and return files, evidence, and residual risks.`
     }),
@@ -66,7 +67,7 @@ Make the smallest defensible change, run focused verification, and return files,
         aliases: ['expert'],
         codexName: 'expert',
         description: 'Read-only reasoning fallback for ambiguous analysis when no narrower specialist matches.',
-        model: 'gpt-5.6-sol',
+        policy: 'sol_max_judgment',
         sandbox: 'read-only',
         keywords: ['ambiguous', 'strategy', 'planning', 'trade-off', 'risk', 'judgment'],
         nicknames: ['Atlas', 'Delta', 'Helix', 'Orion', 'Sage', 'Vector'],
@@ -88,18 +89,34 @@ Return a concise result, evidence, risks, and next action.`
         filename: 'explorer.toml',
         aliases: ['explorer', 'code-explorer'],
         codexName: 'explorer',
-        description: 'Read-only codebase explorer for locating entry points, ownership, dependencies, and bounded evidence before changes.',
-        model: 'gpt-5.6-luna',
+        description: 'Terra Medium read-only codebase explorer for read-heavy scans, entry points, ownership, dependencies, and distilled evidence.',
+        policy: 'terra_medium_context_tools',
         sandbox: 'read-only',
         keywords: ['explore', 'map', 'trace', 'inventory', 'locate', 'search', 'read-only'],
         nicknames: ['Beacon', 'Compass', 'Maple', 'Scout'],
         instructions: `You are the read-only code explorer.
 
 Map only the code paths relevant to the assigned question.
-Prefer targeted search and exact symbol references over broad repository scans.
+Prefer targeted search and exact symbol references, but use this role for repository-wide or long-context scans that would be unsafe for Luna.
 Identify entry points, state transitions, owners, and evidence gaps.
 Do not propose a broad redesign and do not edit files.
 Return concise findings with exact paths and symbols.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-long-context-analyst',
+        filename: 'long-context-analyst.toml',
+        aliases: ['long-context-analyst', 'large-context-analyst', 'document-analyst'],
+        codexName: 'long_context_analyst',
+        description: 'Terra Medium read-only analyst for large files, long logs, multi-document context, and distilled evidence handoffs.',
+        policy: 'terra_medium_context_tools',
+        sandbox: 'read-only',
+        keywords: ['long context', 'large file', 'large codebase', 'multi-document', 'supporting documents', 'extensive logs', 'context compression'],
+        nicknames: ['Archive', 'Atlas', 'Mosaic', 'Scroll'],
+        instructions: `You are the long-context evidence analyst.
+
+Read large files, long logs, or multiple supporting documents without turning raw context into unsupported conclusions.
+Return a compact, source-addressable summary to the parent and identify which claims still require Sol Max judgment.
+Use bounded TriWiki anchors first, hydrate only relevant sources, and do not edit files or spawn another subagent.`
     }),
     officialSubagentRole({
         id: 'sks-official-debugger',
@@ -107,7 +124,7 @@ Return concise findings with exact paths and symbols.`
         aliases: ['debugger', 'root-cause'],
         codexName: 'debugger',
         description: 'Read-only root-cause specialist for failures, flaky behavior, regressions, and cross-layer diagnostics.',
-        model: 'gpt-5.6-sol',
+        policy: 'sol_max_judgment',
         sandbox: 'read-only',
         keywords: ['debug', 'diagnose', 'root cause', 'failure', 'flaky', 'regression', 'why'],
         nicknames: ['Ada', 'Kepler', 'Trace', 'Vega'],
@@ -124,7 +141,7 @@ Return the minimal causal chain, exact evidence, and the smallest defensible fix
         aliases: ['test-engineer', 'qa-engineer'],
         codexName: 'test_engineer',
         description: 'Test engineer for focused regression coverage, deterministic fixtures, and failure-oriented verification.',
-        model: 'gpt-5.6-sol',
+        policy: 'sol_max_judgment',
         keywords: ['test', 'qa', 'fixture', 'regression', 'coverage', 'verification'],
         nicknames: ['Check', 'Proof', 'Quill', 'Tess'],
         instructions: `You are the focused test engineer.
@@ -139,8 +156,8 @@ Run only the focused checks needed for the slice and report exact commands and o
         filename: 'ui-implementer.toml',
         aliases: ['ui-implementer', 'frontend-specialist'],
         codexName: 'ui_implementer',
-        description: 'UI and terminal-interface implementation specialist for visual behavior, interaction, accessibility, and rendered state.',
-        model: 'gpt-5.6-sol',
+        description: 'Sol High UI and terminal-interface implementation specialist for visual behavior, interaction, accessibility, and rendered state.',
+        policy: 'sol_high_implementation',
         keywords: ['ui', 'ux', 'frontend', 'visual', 'terminal', 'zellij', 'pane', 'accessibility'],
         nicknames: ['Canvas', 'Iris', 'Pixel', 'Turing'],
         instructions: `You are the UI implementation specialist.
@@ -149,6 +166,136 @@ Trace the rendered user-visible behavior before editing.
 Make the smallest change that fixes interaction, layout, accessibility, or terminal presentation.
 Preserve the existing design system and unrelated behavior.
 Verify the rendered result with the appropriate live or deterministic surface and report evidence.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-native-app-specialist',
+        filename: 'native-app-specialist.toml',
+        aliases: ['native-app-specialist', 'macos-specialist', 'desktop-specialist'],
+        codexName: 'native_app_specialist',
+        description: 'Sol High native desktop coding specialist for macOS AppKit and Swift menu-bar UI, app lifecycle, accessibility, and OS integration.',
+        policy: 'sol_high_implementation',
+        keywords: ['native app', 'macos', 'appkit', 'swift', 'menu bar', 'nsstatusitem', 'nsworkspace', 'tcc', 'desktop app'],
+        nicknames: ['Cocoa', 'Darwin', 'Quartz', 'Swift'],
+        instructions: `You are the native desktop implementation specialist.
+
+Own only the assigned native macOS, AppKit, Swift, or menu-bar files.
+Preserve the project design system, accessibility semantics, app lifecycle, and OS permission boundaries.
+Do not substitute web UI or placeholder assets for required native behavior.
+Verify with the narrowest compile, deterministic template, or live native check available and report exact evidence.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-computer-use-operator',
+        filename: 'computer-use-operator.toml',
+        aliases: ['computer-use-operator', 'desktop-operator'],
+        codexName: 'computer_use_operator',
+        description: 'Terra Medium Computer Use operator for scoped native macOS, desktop-app, and OS-settings interaction or evidence capture.',
+        policy: 'terra_medium_context_tools',
+        sandbox: 'read-only',
+        keywords: ['computer use', 'desktop interaction', 'macos inspection', 'system settings', 'native app inspection', 'visual evidence'],
+        nicknames: ['Cursor', 'Finder', 'Orbit', 'Quartz'],
+        instructions: `You are the scoped Computer Use operator.
+
+Use Codex Computer Use only for the explicit native macOS, desktop-app, OS-settings, or non-web visual slice assigned by the parent.
+Do not replace judgment, debugging, planning, or security review; return captured evidence to the appropriate Sol Max specialist.
+Honor the parent permission scope, avoid destructive or irreversible UI actions, do not edit source files, and report exactly what was observed or changed.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-browser-use-operator',
+        filename: 'browser-use-operator.toml',
+        aliases: ['browser-use-operator', 'chrome-operator', 'web-operator'],
+        codexName: 'browser_use_operator',
+        description: 'Terra Medium Browser/Chrome operator for scoped website, localhost, webapp, and browser-based evidence collection or verification.',
+        policy: 'terra_medium_context_tools',
+        sandbox: 'read-only',
+        keywords: ['browser use', 'browser', 'chrome', 'website', 'webapp', 'localhost', 'playwright', 'browser evidence'],
+        nicknames: ['Chrome', 'Lens', 'Navigator', 'Tab'],
+        instructions: `You are the scoped Browser/Chrome operator.
+
+Use the Codex Chrome Extension path first for websites, localhost, webapps, and browser-based verification, and halt rapidly when the required extension is unavailable.
+Do not perform security, UX, debugging, or product judgment; collect precise browser evidence and hand it to the relevant Sol Max specialist.
+Honor the parent permission scope, avoid destructive external actions, do not edit source files, and report URLs or sensitive values only in redacted form.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-image-generation-operator',
+        filename: 'image-generation-operator.toml',
+        aliases: ['image-generation-operator', 'imagegen-operator', 'image-tool-operator'],
+        codexName: 'image_generation_operator',
+        description: 'Terra Medium image-generation operator for scoped imagegen and GPT Image execution after the parent seals the visual requirements.',
+        policy: 'terra_medium_context_tools',
+        keywords: ['image generation', 'imagegen', 'gpt image', 'gpt-image-2', 'generate image', 'edit image', 'visual asset'],
+        nicknames: ['Aperture', 'Frame', 'Palette', 'Render'],
+        instructions: `You are the scoped image-generation operator.
+
+Execute only the sealed image-generation or image-editing instructions supplied by the parent, using the official Codex image generation surface when available.
+Do not perform UX review, art-direction judgment, or product strategy; return generated artifact paths and tool evidence to a Sol Max reviewer when judgment is required.
+Write only assigned generated-asset paths, preserve source images, and never fabricate successful image output.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-toolchain-specialist',
+        filename: 'toolchain-specialist.toml',
+        aliases: ['toolchain-specialist', 'build-specialist', 'dependency-specialist'],
+        codexName: 'toolchain_specialist',
+        description: 'Build and toolchain implementation specialist for dependency and runtime upgrades, package scripts, install/doctor/update flows, and CI automation.',
+        policy: 'sol_max_judgment',
+        keywords: ['toolchain', 'dependency upgrade', 'runtime upgrade', 'package manager', 'npm', 'pnpm', 'cargo', 'build script', 'install flow', 'doctor flow', 'update flow', 'ci automation'],
+        nicknames: ['Anvil', 'Bolt', 'Crank', 'Gear'],
+        instructions: `You are the build and toolchain implementation specialist.
+
+Own only the assigned dependency, runtime, package, install, doctor, update, or CI files.
+For external package or runtime changes, use current documentation evidence supplied through Context7 or official vendor sources; do not guess syntax or versions.
+Preserve reproducibility, idempotency, lockfile truth, and user-owned configuration.
+Run focused build or packaging checks and report exact commands, outputs, and remaining compatibility risk.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-protocol-reviewer',
+        filename: 'protocol-reviewer.toml',
+        aliases: ['protocol-reviewer', 'contract-reviewer', 'api-contract-reviewer'],
+        codexName: 'protocol_reviewer',
+        description: 'Read-only protocol and contract reviewer for MCP, CLI, SDK, API, schemas, serialization, and backward compatibility.',
+        policy: 'sol_max_judgment',
+        sandbox: 'read-only',
+        keywords: ['protocol', 'contract', 'mcp', 'cli contract', 'sdk', 'api contract', 'schema', 'serialization', 'wire format', 'backward compatibility'],
+        nicknames: ['Handshake', 'IETF', 'Packet', 'Schema'],
+        instructions: `You are the protocol and contract reviewer.
+
+Trace only the assigned MCP, CLI, SDK, API, schema, serialization, or wire-format boundary.
+Compare producers, consumers, validation, versioning, and error behavior from current source and current official documentation when external contracts apply.
+Stay read-only and do not infer compatibility from types alone.
+Return concrete contract mismatches, affected callers, compatibility severity, and the smallest verification needed.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-runtime-reliability-reviewer',
+        filename: 'runtime-reliability-reviewer.toml',
+        aliases: ['runtime-reliability-reviewer', 'reliability-reviewer', 'lifecycle-reviewer'],
+        codexName: 'runtime_reliability_reviewer',
+        description: 'Read-only runtime reliability reviewer for hooks, sessions, locks, daemons, process cleanup, idempotency, recovery, and race conditions.',
+        policy: 'sol_max_judgment',
+        sandbox: 'read-only',
+        keywords: ['runtime reliability', 'hook lifecycle', 'session', 'lock', 'daemon', 'process cleanup', 'idempotency', 'recovery', 'race condition', 'deadlock'],
+        nicknames: ['Latch', 'Relay', 'Semaphore', 'Uptime'],
+        instructions: `You are the runtime reliability reviewer.
+
+Trace the assigned lifecycle across hooks, sessions, locks, daemons, subprocesses, cleanup, retries, and recovery.
+Stay read-only; distinguish deterministic evidence from timing hypotheses.
+Check idempotency, ownership, stale-state handling, timeout behavior, and race or deadlock risk.
+Return the causal state sequence, severity, exact evidence, and focused concurrency or recovery checks.`
+    }),
+    officialSubagentRole({
+        id: 'sks-official-triwiki-evidence-reviewer',
+        filename: 'triwiki-evidence-reviewer.toml',
+        aliases: ['triwiki-evidence-reviewer', 'evidence-reviewer', 'provenance-reviewer'],
+        codexName: 'triwiki_evidence_reviewer',
+        description: 'Read-only TriWiki and evidence reviewer for bounded recall, provenance, trust anchors, wrongness memory, proof artifacts, and unsupported claims.',
+        policy: 'sol_max_judgment',
+        sandbox: 'read-only',
+        keywords: ['triwiki', 'context pack', 'provenance', 'trust anchor', 'proof artifact', 'wrongness memory', 'unsupported claim', 'source hydration'],
+        nicknames: ['Anchor', 'Ledger', 'Proof', 'Source'],
+        instructions: `You are the TriWiki and evidence reviewer.
+
+Consume compact attention.use_first anchors first and hydrate only sources relevant to the assigned claim or risky decision.
+Never inject or reread the full context pack by default.
+Stay read-only and check provenance, source freshness, trust anchors, wrongness memory, proof artifacts, and unsupported completion claims.
+Return claim-to-source findings, stale or missing evidence, confidence, and the minimum hydration or validation still required.`
     }),
     officialSubagentRole({
         id: 'sks-official-architecture-reviewer',
@@ -156,7 +303,7 @@ Verify the rendered result with the appropriate live or deterministic surface an
         aliases: ['architecture-reviewer', 'architect'],
         codexName: 'architecture_reviewer',
         description: 'Read-only architecture reviewer for boundaries, lifecycle, state ownership, coupling, and refactor risk.',
-        model: 'gpt-5.6-sol',
+        policy: 'sol_max_judgment',
         sandbox: 'read-only',
         keywords: ['architecture', 'design', 'lifecycle', 'state ownership', 'refactor', 'coupling'],
         nicknames: ['Archimedes', 'Euler', 'Frame', 'Mencius'],
@@ -173,7 +320,7 @@ Do not edit files; return prioritized findings and a bounded recommendation.`
         aliases: ['security-reviewer', 'security'],
         codexName: 'security_reviewer',
         description: 'Read-only security reviewer for trust boundaries, permissions, secrets, authentication, and abuse cases.',
-        model: 'gpt-5.6-sol',
+        policy: 'sol_max_judgment',
         sandbox: 'read-only',
         keywords: ['security', 'permission', 'secret', 'auth', 'trust boundary', 'abuse'],
         nicknames: ['Aegis', 'Cipher', 'Sentinel', 'Shield'],
@@ -190,7 +337,7 @@ Return findings with severity, evidence, exploit preconditions, and the smallest
         aliases: ['database-reviewer', 'db-reviewer'],
         codexName: 'database_reviewer',
         description: 'Read-only database reviewer for SQL, migrations, schemas, RLS, rollback safety, and data integrity.',
-        model: 'gpt-5.6-sol',
+        policy: 'sol_max_judgment',
         sandbox: 'read-only',
         keywords: ['database', 'db', 'sql', 'migration', 'schema', 'rls', 'rollback'],
         nicknames: ['Ledger', 'Oracle', 'Rowan', 'Schema'],
@@ -207,7 +354,7 @@ Return exact risks, evidence, and safe verification or migration recommendations
         aliases: ['research-synthesizer', 'researcher'],
         codexName: 'research_synthesizer',
         description: 'Evidence-bound research specialist for source synthesis, falsification, novelty, and adversarial manuscript improvement.',
-        model: 'gpt-5.6-sol',
+        policy: 'sol_max_judgment',
         keywords: ['research', 'paper', 'hypothesis', 'synthesis', 'falsification', 'novelty', 'super search'],
         nicknames: ['Curie', 'Einstein', 'Feynman', 'Noether'],
         instructions: `You are the evidence-bound research synthesizer.
@@ -224,7 +371,7 @@ Return a structured synthesis, strongest challenge, required revisions, and resi
         aliases: ['research-reviewer', 'paper-reviewer'],
         codexName: 'research_reviewer',
         description: 'Read-only adversarial research reviewer for evidence quality, falsification, methodology, novelty, and reproducibility.',
-        model: 'gpt-5.6-sol',
+        policy: 'sol_max_judgment',
         sandbox: 'read-only',
         keywords: ['research review', 'paper review', 'adversarial review', 'methodology', 'reproducibility', 'falsification'],
         nicknames: ['Gauss', 'Skeptic', 'Turing', 'von Neumann'],
@@ -241,7 +388,7 @@ Approve only when no critical, major, minor, or required revision remains.`
         aliases: ['release-reviewer', 'release'],
         codexName: 'release_reviewer',
         description: 'Read-only release reviewer for versioning, package contents, CI, migration safety, and publish authorization.',
-        model: 'gpt-5.6-sol',
+        policy: 'sol_max_judgment',
         sandbox: 'read-only',
         keywords: ['release', 'publish', 'package', 'version', 'changelog', 'ci', 'distribution'],
         nicknames: ['Galileo', 'Harbor', 'Launch', 'Mercury'],
@@ -257,8 +404,8 @@ Return release blockers, exact evidence, and the minimal verification still requ
         filename: 'docs-maintainer.toml',
         aliases: ['docs-maintainer', 'documentation'],
         codexName: 'docs_maintainer',
-        description: 'Documentation maintainer for bounded README, changelog, migration, and reference updates after behavior is known.',
-        model: 'gpt-5.6-luna',
+        description: 'Terra Medium documentation maintainer for multi-source README, changelog, migration, and reference consistency after behavior is known.',
+        policy: 'terra_medium_context_tools',
         keywords: ['docs', 'documentation', 'readme', 'changelog', 'migration guide', 'reference'],
         nicknames: ['Ink', 'Page', 'Scribe', 'Slate'],
         instructions: `You are the bounded documentation maintainer.
@@ -274,7 +421,7 @@ Return changed files and the source of truth used for each behavioral statement.
         aliases: ['integration-reviewer', 'integration'],
         codexName: 'integration_reviewer',
         description: 'Read-only cross-module integration reviewer for merge risk, contracts, compatibility, and end-to-end state flow.',
-        model: 'gpt-5.6-sol',
+        policy: 'sol_max_judgment',
         sandbox: 'read-only',
         keywords: ['integration', 'merge', 'rebase', 'compatibility', 'cross-module', 'end-to-end'],
         nicknames: ['Bridge', 'Concord', 'Link', 'Weave'],
@@ -291,7 +438,7 @@ Return concrete integration risks and focused checks.`
         aliases: ['performance-analyst', 'performance'],
         codexName: 'performance_analyst',
         description: 'Read-only performance analyst for latency, concurrency, token cost, resource usage, and benchmark validity.',
-        model: 'gpt-5.6-sol',
+        policy: 'sol_max_judgment',
         sandbox: 'read-only',
         keywords: ['performance', 'latency', 'benchmark', 'concurrency', 'token', 'memory', 'throughput'],
         nicknames: ['Ampere', 'Hopper', 'Pulse', 'Watt'],
@@ -461,14 +608,16 @@ function role(id, filename, codexName, description, sandbox, aliases) {
     };
 }
 function officialSubagentRole(input) {
+    const profile = subagentModelProfile(input.policy);
     return {
         id: input.id,
         filename: input.filename,
         aliases: input.aliases,
         codex_name: input.codexName,
         description: input.description,
-        model: input.model,
-        model_reasoning_effort: 'max',
+        model_policy: profile.policy,
+        model: profile.model,
+        model_reasoning_effort: profile.modelReasoningEffort,
         ...(input.sandbox ? { sandbox: input.sandbox } : {}),
         nickname_candidates: input.nicknames,
         selection_keywords: input.keywords,

package/dist/core/preflight/parallel-preflight-engine.js

@@ -43,12 +43,18 @@ export async function runCodexLaunchPreflight(rootInput = process.cwd(), opts =
         { id: 'codex_project_config_policy', run: () => splitCodexProjectConfigPolicy(root, { ...opts, writeReport: false }) },
         { id: 'codex_lb_tool_output_recovery', run: () => inspectCodexLbToolOutputRecoveryForLaunch(opts) }
     ]);
-    const repair = opts.fix === true || readonly.ok === false
-        ? await repairCodexConfigEperm(root, { ...opts, codexProbe: probeCodex, actualCodex: probeCodex, fix: opts.fix !== false, writeReport: false })
+    // A failed read-only preflight must not invoke the full repair inspector unless
+    // the operator explicitly requested repair. The repair path re-runs readability
+    // before and after its work; on macOS ACL/TCC failures those repeated 5s probes
+    // used to compound into minute-scale `sks --mad` startup delays even though no
+    // mutation was authorized. Keep the blocker from the first pass and fail fast.
+    const repair = opts.fix === true
+        ? await repairCodexConfigEperm(root, { ...opts, codexProbe: probeCodex, actualCodex: probeCodex, fix: true, writeReport: false })
         : null;
+    const providedZellijCapability = reusableZellijCapability(opts.zellijCapability, opts.requireZellij === true);
     const zellijCapability = opts.zellijCapability === false
         ? null
-        : await checkZellijCapability({ root, require: opts.requireZellij === true, writeReport: false });
+        : providedZellijCapability || await checkZellijCapability({ root, require: opts.requireZellij === true, writeReport: false });
     const codexArgs = buildCodexExecArgs({
         json: true,
         outputLastMessage: path.join(root, '.sneakoscope', 'reports', 'codex-preflight-output.json'),
@@ -87,6 +93,13 @@ export async function runCodexLaunchPreflight(rootInput = process.cwd(), opts =
         await writeJsonAtomic(reportPath, { ...report, report_path: reportPath });
     return report;
 }
+function reusableZellijCapability(value, requireZellij) {
+    if (!value || value.schema !== 'sks.zellij-capability.v1' || typeof value.status !== 'string')
+        return null;
+    if (requireZellij && value.status !== 'ok')
+        return null;
+    return value;
+}
 export async function inspectCodexLbToolOutputRecoveryForLaunch(opts = {}) {
     if (opts.skipCodexLbToolOutputRecovery === true) {
         return {

package/dist/core/proof/route-adapter.js

@@ -116,7 +116,7 @@ async function runPostRouteRetention(root, missionId) {
             afterRoute: true,
             completedMissionId: missionId,
             pruneReportLogs: false,
-            policy: { max_tmp_age_hours: 0 }
+            skipSksTempSweep: true
         });
         return {
             ok: true,

package/dist/core/proof/selftest-proof-fixtures.js

@@ -28,11 +28,9 @@ export async function writeSelftestRouteProof(root, { missionId, route = '$Team'
         route,
         // This fixture writes into a scratch temp directory (see selftestCommand's
         // `tmpdir('sks-selftest-')`) that is discarded after the call returns, so trust
-        // artifacts and post-route retention are pointless here. Worse than pointless:
-        // writeRouteCompletionProof's default path runs runPostRouteRetention() with
-        // `max_tmp_age_hours: 0`, which swept the just-written completion-proof.json
-        // before the caller could read it back, making `sks selftest --mock` fail with
-        // "completion proof fixture missing" even though the proof was written correctly.
+        // artifacts and post-route retention are pointless here. The production
+        // post-route path now skips global temp sweeping, but this mock fixture still
+        // avoids unnecessary trust/retention work before its caller removes the root.
         lightweightEvidence: true,
         status: 'mock_only',
         executionClass: 'mock_fixture',

package/dist/core/provider/model-router.js

@@ -1,4 +1,4 @@
-import { decideSubagentModel, SUBAGENT_EFFORT } from '../subagents/model-policy.js';
+import { DEFAULT_SUBAGENT_EFFORT, LUNA_SUBAGENT_EFFORT, SOL_MAX_SUBAGENT_EFFORT, TERRA_SUBAGENT_EFFORT, decideSubagentModel } from '../subagents/model-policy.js';
 const CATEGORY_POLICY = {
     quick: { reasoning: 'low', serviceTier: 'fast' },
     standard: { reasoning: 'medium', serviceTier: 'fast' },
@@ -10,8 +10,7 @@ const CATEGORY_POLICY = {
     refactor: { reasoning: 'max', serviceTier: 'fast' },
     strategy: { reasoning: 'max', serviceTier: 'fast' }
 };
-export const NARUTO_MODELS = ['gpt-5.6-luna', 'gpt-5.6-sol'];
-const NARUTO_EXPLICIT_COMPATIBILITY_MODELS = [...NARUTO_MODELS, 'gpt-5.6-terra'];
+export const NARUTO_MODELS = ['gpt-5.6-luna', 'gpt-5.6-terra', 'gpt-5.6-sol'];
 const E2E_WORK_RE = /(e2e|end[-\s]?to[-\s]?end|test_execution|browser|chrome|computer[-\s]?use|computer\s+use|cross[-\s]?app|playwright|selenium|puppeteer|브라우저|컴퓨터\s*유즈)/i;
 export async function routeModel(category, opts = {}) {
     if (opts.narutoOnly) {
@@ -39,6 +38,7 @@ export function routeNarutoGpt56Model(input = {}) {
         title: input.taskText,
         description: input.riskText,
         role: category,
+        toolHeavy: category === 'e2e',
         requiresJudgment: category === 'review'
             || category === 'refactor'
             || category === 'strategy'
@@ -46,12 +46,14 @@ export function routeNarutoGpt56Model(input = {}) {
     });
     const preferred = explicit || automatic.model;
     const available = input.availableModels == null
-        ? [...NARUTO_EXPLICIT_COMPATIBILITY_MODELS]
+        ? [...NARUTO_MODELS]
         : input.availableModels.map(normalizeNarutoGpt56Model).filter((model) => Boolean(model));
     const degraded = new Set((input.degradedModels || []).map((model) => String(model).toLowerCase()));
     const usable = available.filter((model) => !degraded.has(model));
     const availableEfforts = effortsForModel(input.availableModelEfforts, preferred);
-    const intendedReasoning = SUBAGENT_EFFORT;
+    const intendedReasoning = explicit
+        ? reasoningForExplicitModel(explicit, automatic.policy === 'sol_max_judgment')
+        : automatic.modelReasoningEffort;
     const model = !invalidExplicit && usable.includes(preferred) && (availableEfforts == null || availableEfforts.includes(intendedReasoning)) ? preferred : '';
     return { model, reasoning: intendedReasoning, serviceTier: 'fast' };
 }
@@ -60,7 +62,7 @@ export function isNarutoGpt56Model(value) {
 }
 export function normalizeNarutoGpt56Model(value) {
     const model = String(value || '').trim().toLowerCase();
-    return NARUTO_EXPLICIT_COMPATIBILITY_MODELS.includes(model) ? model : null;
+    return NARUTO_MODELS.includes(model) ? model : null;
 }
 export function categoryForWorkerRole(role, taskText = '') {
     const text = `${String(role || '')} ${String(taskText || '')}`.toLowerCase();
@@ -98,4 +100,11 @@ function effortsForModel(catalog, model) {
     const match = Object.entries(catalog).find(([key]) => key.trim().toLowerCase() === model);
     return (match?.[1] || []).map((effort) => String(effort).toLowerCase());
 }
+function reasoningForExplicitModel(model, judgment) {
+    if (model === 'gpt-5.6-luna')
+        return LUNA_SUBAGENT_EFFORT;
+    if (model === 'gpt-5.6-terra')
+        return TERRA_SUBAGENT_EFFORT;
+    return judgment ? SOL_MAX_SUBAGENT_EFFORT : DEFAULT_SUBAGENT_EFFORT;
+}
 //# sourceMappingURL=model-router.js.map

package/dist/core/release/package-size-budget.js

@@ -1,7 +1,5 @@
-export const DEFAULT_MAX_PACK_BYTES = 2414 * 1024;
-// 6.1.2 measured 11,016,751 unpacked bytes after the final official custom-
-// agent catalog, Super Search provenance validation, and live Zellij activity
-// reader were included. Keep a narrow 10.53125 MiB ceiling shared by every
-// package-size gate; packed bytes remain under the existing 2414 KiB limit.
-export const DEFAULT_MAX_UNPACKED_BYTES = 11_042_816;
+// 6.2.0 measured ceiling: next narrow packed boundary.
+export const DEFAULT_MAX_PACK_BYTES = 2428 * 1024;
+// 6.2.0 measured ceiling: next narrow unpacked boundary.
+export const DEFAULT_MAX_UNPACKED_BYTES = 11_141_120;
 //# sourceMappingURL=package-size-budget.js.map

package/dist/core/research/research-plan-markdown.js

@@ -0,0 +1,123 @@
+export function renderResearchPlanMarkdown(plan, helpers) {
+    const lines = [];
+    lines.push('# SKS Research Plan');
+    lines.push('');
+    lines.push(`Prompt: ${plan.prompt}`);
+    lines.push(`Depth: ${plan.depth}`);
+    lines.push(`Methodology: ${plan.methodology}`);
+    lines.push(`Research paper: ${helpers.researchPaperArtifactForPlan(plan)}`);
+    if (plan.codex_app_execution_profile) {
+        lines.push(`Execution profile: ${plan.codex_app_execution_profile.mode}; agent role strategy ${plan.codex_app_execution_profile.agent_role_strategy}`);
+    }
+    if (plan.execution_policy) {
+        lines.push(`Execution: ${plan.execution_policy.normal_run}; default cycle timeout ${plan.execution_policy.default_cycle_timeout_minutes} minutes`);
+        if (plan.execution_policy.default_max_cycles)
+            lines.push(`Adversarial review loop: run three independent official research_reviewer threads, revise on any objection, then run a fresh three-thread cycle; default safety cap ${plan.execution_policy.default_max_cycles} cycles`);
+        lines.push(`Mock policy: ${plan.execution_policy.mock_policy}`);
+    }
+    if (plan.mutation_policy)
+        lines.push(`Mutation policy: ${plan.mutation_policy.rule}`);
+    lines.push('');
+    if (plan.quality_contract) {
+        const contract = plan.quality_contract;
+        lines.push('## Quality Contract');
+        lines.push(`- minimum sources: ${contract.min_sources_total}`);
+        lines.push(`- minimum source layers covered: ${contract.min_source_layers_covered}`);
+        lines.push(`- minimum counterevidence sources: ${contract.min_counterevidence_sources}`);
+        lines.push(`- minimum key claims: ${contract.min_key_claims}`);
+        lines.push(`- minimum triangulated claims: ${contract.min_trianguled_claims}`);
+        lines.push(`- minimum blueprint sections: ${contract.min_implementation_blueprint_sections}`);
+        lines.push(`- minimum falsification cases: ${contract.min_falsification_cases}`);
+        lines.push(`- minimum experiment steps: ${contract.min_experiment_steps}`);
+        lines.push(`- minimum report words: ${contract.min_report_words}`);
+        lines.push('');
+    }
+    if (plan.native_agent_plan) {
+        lines.push('## Official Subagent Review Plan');
+        lines.push(`Backend: ${plan.native_agent_plan.backend}`);
+        lines.push(`Sessions: ${plan.native_agent_plan.session_count}`);
+        lines.push(`AutoResearch batches: ${plan.native_agent_plan.autoresearch_cycle_policy?.uses_agent_batches ? 'enabled' : 'disabled'}`);
+        for (const persona of plan.native_agent_plan.personas || []) {
+            lines.push(`- ${persona.id}: ${persona.role}; outputs ${(persona.outputs || []).join(', ')}`);
+        }
+        for (const batch of plan.native_agent_plan.batches || []) {
+            lines.push(`- batch ${batch.id}: ${(batch.agents || []).join(', ')} -> ${(batch.outputs || []).join(', ')}`);
+        }
+        lines.push('');
+    }
+    lines.push('## Rules');
+    for (const rule of plan.rules)
+        lines.push(`- ${rule}`);
+    lines.push('');
+    if (plan.research_council?.agents?.length) {
+        lines.push('## Genius Agent Council');
+        lines.push(`Policy: ${plan.research_council.policy}`);
+        for (const agent of plan.research_council.agents)
+            lines.push(`- ${helpers.researchAgentAgentName(agent)}: ${agent.persona || agent.role} - ${agent.mandate} (${agent.persona_boundary || 'persona-inspired lens only'})`);
+        lines.push('');
+    }
+    if (plan.web_research_policy) {
+        lines.push('## Web Research Policy');
+        lines.push(`Mode: ${plan.web_research_policy.mode}`);
+        lines.push(`Requirement: ${plan.web_research_policy.requirement}`);
+        if (plan.web_research_policy.source_tool_routing)
+            lines.push(`Source tool routing: ${plan.web_research_policy.source_tool_routing.mode}`);
+        for (const querySet of plan.web_research_policy.query_sets || [])
+            lines.push(`- query set: ${querySet}`);
+        if (plan.web_research_policy.skill_creator?.artifact)
+            lines.push(`- source skill artifact: ${plan.web_research_policy.skill_creator.artifact}`);
+        for (const layer of plan.web_research_policy.source_layers || []) {
+            lines.push(`- layer ${layer.id}: ${layer.purpose}`);
+        }
+        lines.push('');
+    }
+    lines.push('## Outcome Rubric');
+    for (const item of plan.outcome_rubric || [])
+        lines.push(`- ${item.id}: ${item.description}`);
+    lines.push('');
+    lines.push('## Phases');
+    for (const phase of plan.phases)
+        lines.push(`- ${phase.id}: ${phase.goal}`);
+    lines.push('');
+    lines.push('## Required Artifacts');
+    for (const artifact of plan.required_artifacts)
+        lines.push(`- ${artifact}`);
+    lines.push('');
+    return `${lines.join('\n')}\n`;
+}
+export function renderResearchSourceSkillMarkdown(plan, defaultLayers) {
+    const layers = plan?.web_research_policy?.source_layers?.length ? plan.web_research_policy.source_layers : defaultLayers;
+    const lines = [];
+    lines.push('# Research Source Layer Skill');
+    lines.push('');
+    lines.push('Status: route-local candidate skill. Use it inside this research mission before agent synthesis. Do not install or edit generated .agents/skills from this artifact.');
+    lines.push('Real-run policy: collect live sources for as long as needed within the mission timeout; mock or fixture evidence is valid only for explicit --mock selftests.');
+    lines.push('');
+    lines.push('## Trigger');
+    lines.push('- Any `$Research` run that must collect broad public evidence before synthesis, adversarial review, falsification, or paper writing.');
+    lines.push('');
+    lines.push('## Source Layers');
+    for (const layer of layers) {
+        lines.push(`- ${layer.id}: ${layer.purpose}`);
+        lines.push(`  Examples: ${(layer.examples || []).join(', ')}`);
+        lines.push(`  Query templates: ${(layer.query_templates || []).join(' | ')}`);
+    }
+    lines.push('');
+    lines.push('## Output Contract');
+    lines.push('- Fill source-ledger.json with `source_layers`, `sources[].layer`, `counterevidence_sources[].layer`, `citation_coverage`, `triangulation.cross_layer_checks`, and `blockers`.');
+    lines.push('- Each source entry should record title, locator/URL, publisher or author when known, published_at when known, accessed_at, layer, reliability, credibility, stance, supports or undermines, and notes.');
+    lines.push('- Public discourse sources such as X/Twitter or Reddit are signals and edge cases, not truth. They must be triangulated with formal, official, practitioner, or counterevidence layers.');
+    lines.push('- If a layer cannot be searched with the available runtime or credentials, record the blocker and keep research-gate.json unpassed.');
+    lines.push('- Do not modify repository source code or generated harness files during Research; write only route-local mission artifacts.');
+    lines.push('');
+    lines.push('## Official Reviewer Use');
+    lines.push('- Only source-ledger ids with correlated verified-content Super Search proof may support a real-run reviewer finding or Eureka idea.');
+    lines.push('- Run exactly three independent official `research_reviewer` threads on GPT-5.6 Sol Max: Einstein, von Neumann, and Skeptic composite lenses.');
+    lines.push('- The skeptic lens must challenge the strongest claim using counterevidence or source-quality downgrades.');
+    lines.push('- Any objection triggers a mission-local `research_synthesizer` revision followed by a fresh three-thread review cycle; do not launch a custom scheduler or debate pool.');
+    lines.push('- `agent-ledger.json` and `debate-ledger.json` are compatibility projections from official reviewer outcomes. Canonical convergence requires three trustworthy parent outcomes and zero unresolved objections.');
+    lines.push('- Synthesis keeps only claims that survive cross-layer triangulation and falsification.');
+    lines.push('');
+    return `${lines.join('\n')}\n`;
+}
+//# sourceMappingURL=research-plan-markdown.js.map