sneakoscope 6.0.2 → 6.1.0

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

@@ -1,5 +1,6 @@
 import { codexModelEffortCapability } from '../codex-control/codex-model-capabilities.js';
 import { GLM_52_OPENROUTER_MODEL } from '../providers/glm/glm-52-settings.js';
+import { isNarutoGpt56Model, routeNarutoGpt56Model } from '../provider/model-router.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;
@@ -60,52 +61,47 @@ export function decideAgentEffort(input = {}) {
         ]
     };
 }
-// Any action-tool signal (write/run/search/mcp/db/etc.) lifts a clone to medium.
-// Passive reading alone does not count — "really simple" no-tool work stays at low.
-const NARUTO_ACTION_TOOL_RE = /(write|edit|create|modif|delete|remove|run\b|exec|command|bash|shell|script|install|build|test|migrat|patch|apply|fetch|curl|http|mcp|sql|database|\bdb\b|deploy|commit|push|rename|refactor|generate|scaffold|작성|수정|생성|삭제|실행|명령|빌드|테스트|설치|배포|패치|커밋|마이그레이션)/i;
-// $Naruto shadow-clone effort policy: dynamic like team mode, but capped.
-//   - truly simple / no tool use  -> low
-//   - any tool use (one is enough) -> medium
-//   - NEVER escalates to high/xhigh
-//   - ALWAYS fast service tier
+// $Naruto workers use the codex-lb GPT-5.6 family only. Model and effort are
+// selected by the actual work kind; the removed low/medium cap must never be
+// reintroduced through tool-count or read-only heuristics.
 export function decideNarutoCloneEffort(input = {}) {
     const persona = input.persona || {};
     const prompt = String(input.prompt || '');
     const role = String(persona.role || '');
     const agentId = String(input.agentId || persona.id || 'naruto_clone');
-    const readonly = input.readonly === true || persona.read_only === true;
-    const allowedTools = Array.isArray(persona.allowed_tools) ? persona.allowed_tools : [];
-    const writePolicy = String(persona.write_policy || '');
-    // Tool use is driven by (a) write capability, (b) the persona's actual action tools, or
-    // (c) the work prompt itself — NOT by incidental persona prose (role/risk_focus), so a
-    // read-only analysis clone on a no-tool prompt stays at low. Passive Read/Grep ≠ tool use.
-    const hasActionTool = allowedTools.some((tool) => /write|edit|create|bash|shell|command|exec|run|mcp|patch|apply|multiedit|notebook/i.test(String(tool)));
-    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 modelDecision = decideAgentWorkerModel({ effort, prompt, role, agentId, readonly, writePolicy: String(writePolicy || '') });
-    const modelCapability = codexModelEffortCapability({ model: modelDecision.model, defaultEffort: modelDecision.model_reasoning_effort });
+    const taskText = [role, agentId, persona.naruto_role].join(' ');
+    const riskText = [prompt, persona.risk_focus, persona.write_policy].join(' ');
+    const routed = routeNarutoGpt56Model({ taskText, riskText });
+    const effort = routed.reasoning;
+    const modelCapability = codexModelEffortCapability({
+        model: routed.model,
+        advertisedEfforts: narutoAdvertisedEfforts(routed.model),
+        defaultEffort: effort
+    });
     return {
         schema: 'sks.agent-effort-decision.v1',
         policy_version: 1,
         agent_id: agentId,
         role,
-        model: modelDecision.model,
+        model: routed.model,
         reasoning_effort: effort,
-        model_reasoning_effort: modelDecision.model_reasoning_effort,
-        model_tier: modelDecision.model_tier,
-        model_profile: modelDecision.model_profile,
-        model_selection_reason: modelDecision.reason,
+        model_reasoning_effort: effort,
+        model_tier: `${routed.model}-${effort}`,
+        model_profile: `sks-naruto-${safeProfileSegment(routed.model)}-${effort}-fast`,
+        model_selection_reason: narutoSelectionReason(routed.model, effort),
         model_effort_capability: modelCapability,
         reasoning_profile: reasoningProfileName(effort),
         service_tier: 'fast',
-        reason: toolUse ? 'naruto_tool_use_medium' : 'naruto_simple_no_tool_low',
+        reason: narutoSelectionReason(routed.model, effort),
         dynamic: true,
         escalation_triggers: [
-            'any tool use (write/edit/run/search/build/mcp/db) lifts the clone from low to medium'
+            'complex or high-risk Terra work escalates from xhigh to max',
+            'complex E2E, browser, Computer Use, or forensic Luna verification escalates from xhigh to max',
+            'refactoring, architecture, planning, strategy, and integration select Sol at max'
         ],
         downshift_triggers: [
-            'truly simple, no-tool, read-only reasoning stays at low'
+            'ordinary coding stays on Terra xhigh',
+            'ordinary E2E, browser, Computer Use, and GUI verification stays on Luna xhigh'
         ]
     };
 }
@@ -124,21 +120,26 @@ export function buildAgentEffortPolicy(roster = {}) {
         reason: agent.reasoning_reason,
         dynamic: true
     })) : [];
+    const narutoFamilyOnly = decisions.length > 0 && decisions.every((decision) => isNarutoGpt56Model(decision.model));
     return {
         schema: 'sks.agent-effort-policy.v1',
         policy_version: 1,
         dynamic: true,
         service_tier: 'fast',
-        model_catalog_policy: 'codex_catalog_passthrough',
-        model_constraint: null,
-        model_tiers: ['codex-selected-low', 'codex-selected-medium', 'codex-selected-high', 'codex-selected-xhigh', 'glm-5.2-minimal', 'glm-5.2-low', 'glm-5.2-high', 'glm-5.2-xhigh'],
-        allowed_efforts: codexModelEffortCapability().advertised_efforts,
+        model_catalog_policy: narutoFamilyOnly ? 'naruto_gpt_5_6_family_dynamic' : 'codex_catalog_passthrough',
+        model_constraint: narutoFamilyOnly ? ['gpt-5.6-luna', 'gpt-5.6-terra', 'gpt-5.6-sol'] : null,
+        model_tiers: narutoFamilyOnly
+            ? ['gpt-5.6-luna-xhigh', 'gpt-5.6-luna-max', 'gpt-5.6-terra-xhigh', 'gpt-5.6-terra-max', 'gpt-5.6-sol-max']
+            : ['codex-selected-low', 'codex-selected-medium', 'codex-selected-high', 'codex-selected-xhigh', 'glm-5.2-minimal', 'glm-5.2-low', 'glm-5.2-high', 'glm-5.2-xhigh'],
+        allowed_efforts: narutoFamilyOnly ? ['xhigh', 'max'] : 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,
         decisions,
-        rule: 'Codex/OpenAI workers inherit the current Codex-selected model, including future catalog entries; SKS changes only advertised reasoning effort. Explicit non-Codex provider modes retain their provider model.'
+        rule: narutoFamilyOnly
+            ? 'Naruto workers use only GPT-5.6 Luna/Terra/Sol: Terra xhigh/max for coding, Sol max for refactoring/planning/strategy/integration, and Luna xhigh/max for E2E/browser/Computer Use/GUI verification.'
+            : 'Codex/OpenAI workers inherit the current Codex-selected model, including future catalog entries; SKS changes only advertised reasoning effort. Explicit non-Codex provider modes retain their provider model.'
     };
 }
 export function reasoningProfileName(effort) {
@@ -164,6 +165,18 @@ function effortReason(effort) {
         return 'simple_bounded_slice';
     return 'default_orchestration_slice';
 }
+function narutoAdvertisedEfforts(model) {
+    return model === 'gpt-5.6-luna'
+        ? ['low', 'medium', 'high', 'xhigh', 'max']
+        : ['low', 'medium', 'high', 'xhigh', 'max', 'ultra'];
+}
+function narutoSelectionReason(model, effort) {
+    if (model === 'gpt-5.6-sol')
+        return `naruto_refactor_plan_strategy_sol_${effort}`;
+    if (model === 'gpt-5.6-luna')
+        return `naruto_e2e_browser_computer_use_luna_${effort}`;
+    return `naruto_coding_terra_${effort}`;
+}
 export function decideAgentWorkerModel(input = {}) {
     const mainModel = String(input.mainModel || process.env.SKS_CODEX_MODEL || process.env.CODEX_MODEL || '').trim();
     const glmMain = isGlmWorkerMode(mainModel);

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

@@ -2,6 +2,7 @@ import fsp from 'node:fs/promises';
 import path from 'node:path';
 import { exists, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
 import { normalizeAgentSessionRows } from './agent-session-rows.js';
+import { resolveOwnedNamespacePath } from './agent-namespace-safety.js';
 export async function runAgentJanitor(input) {
     const staleMs = input.staleMs ?? 30 * 60 * 1000;
     const agentRoot = path.join(input.missionDir, 'agents');
@@ -39,7 +40,7 @@ export async function runAgentJanitor(input) {
     const staleZellijSessions = rawStaleZellijSessions.filter((id) => !activeGenerationSet.has(id));
     const skippedActiveGenerations = rawStaleZellijSessions.filter((id) => activeGenerationSet.has(id));
     const orphanGenerationDirs = await detectOrphanGenerationDirs(agentRoot, new Set(generationRows.map((row) => String(row.artifact_dir || ''))));
-    const orphanTempDirs = await scopedExistingPaths(Array.isArray(namespace?.orphan_temp_dirs) ? namespace.orphan_temp_dirs : [], projectHash);
+    const orphanTempDirs = await scopedExistingPaths(Array.isArray(namespace?.orphan_temp_dirs) ? namespace.orphan_temp_dirs : [], projectHash, namespace?.temp_dir ? [namespace.temp_dir] : []);
     const staleLocks = await scopedStaleLockPaths(namespace?.lock_dir ? [namespace.lock_dir] : [], projectHash, staleMs);
     const cleaned = [];
     if (input.cleanup) {
@@ -103,15 +104,12 @@ async function detectOrphanGenerationDirs(agentRoot, knownGenerationDirs) {
 export async function writeAgentJanitorReport(missionDir, report) {
     await writeJsonAtomic(path.join(missionDir, 'agents', 'agent-janitor-report.json'), report);
 }
-async function scopedExistingPaths(paths, projectHash) {
+async function scopedExistingPaths(paths, projectHash, anchors = []) {
     const out = [];
     for (const candidate of paths) {
-        if (!candidate)
-            continue;
-        if (projectHash && !candidate.includes(projectHash))
-            continue;
-        if (await exists(candidate))
-            out.push(candidate);
+        const owned = await resolveOwnedNamespacePath(candidate, String(projectHash || ''), anchors);
+        if (owned)
+            out.push(owned);
     }
     return out;
 }
@@ -119,9 +117,10 @@ async function scopedStaleLockPaths(paths, projectHash, staleMs) {
     const out = [];
     const now = Date.now();
     for (const dir of paths) {
-        if (!dir || (projectHash && !dir.includes(projectHash)) || !(await exists(dir)))
+        const ownedDir = await resolveOwnedNamespacePath(dir, String(projectHash || ''));
+        if (!ownedDir)
             continue;
-        for (const file of await listFiles(dir)) {
+        for (const file of await listFiles(ownedDir)) {
             const stat = await fsp.stat(file).catch(() => null);
             if (stat && now - stat.mtimeMs > staleMs)
                 out.push(file);

package/dist/core/agents/agent-namespace-safety.js

@@ -0,0 +1,56 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+export function validProjectNamespaceHash(value) {
+    return /^[A-Za-z0-9_-]{4,64}$/.test(String(value || ''));
+}
+export function processReportMatchesProjectNamespace(report, projectHash) {
+    if (!validProjectNamespaceHash(projectHash) || !report || typeof report !== 'object')
+        return false;
+    if (String(report.project_hash || '') === projectHash)
+        return true;
+    if (String(report.root_hash || '') === projectHash)
+        return true;
+    const namespace = String(report.project_namespace || '');
+    return namespace === projectHash || namespace === `sks-${projectHash}` || namespace.startsWith(`sks-${projectHash}-`);
+}
+export async function resolveOwnedNamespacePath(candidate, projectHash, anchors = []) {
+    if (!validProjectNamespaceHash(projectHash))
+        return null;
+    const raw = String(candidate || '');
+    if (!raw || !path.isAbsolute(raw) || raw.includes('\0') || raw.split(/[\\/]+/).includes('..'))
+        return null;
+    const resolved = path.resolve(raw);
+    const stat = await fsp.lstat(resolved).catch(() => null);
+    if (!stat || stat.isSymbolicLink())
+        return null;
+    const real = await fsp.realpath(resolved).catch(() => null);
+    if (!real)
+        return null;
+    const validAnchors = [];
+    for (const value of anchors) {
+        const anchorRaw = String(value || '');
+        if (!anchorRaw || !path.isAbsolute(anchorRaw) || anchorRaw.split(/[\\/]+/).includes('..'))
+            continue;
+        const anchorResolved = path.resolve(anchorRaw);
+        const anchorStat = await fsp.lstat(anchorResolved).catch(() => null);
+        if (!anchorStat?.isDirectory() || anchorStat.isSymbolicLink())
+            continue;
+        const anchorReal = await fsp.realpath(anchorResolved).catch(() => null);
+        if (anchorReal)
+            validAnchors.push({ resolved: anchorResolved, real: anchorReal });
+    }
+    if (validAnchors.length) {
+        return validAnchors.some((anchor) => isWithin(anchor.resolved, resolved) && isWithin(anchor.real, real)) ? resolved : null;
+    }
+    return pathContainsHashToken(resolved, projectHash) && pathContainsHashToken(real, projectHash) ? resolved : null;
+}
+function pathContainsHashToken(value, projectHash) {
+    const escaped = projectHash.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const token = new RegExp(`(^|[-_.])${escaped}($|[-_.])`);
+    return path.resolve(value).split(path.sep).filter(Boolean).some((segment) => token.test(segment));
+}
+function isWithin(parent, candidate) {
+    const rel = path.relative(path.resolve(parent), path.resolve(candidate));
+    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+//# sourceMappingURL=agent-namespace-safety.js.map

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

@@ -53,6 +53,7 @@ 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 { codexTimeoutClassForRoute } from '../codex-control/codex-reliability-shield.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';
 import { runFinalGptReviewStage } from '../pipeline/final-gpt-review-stage.js';
@@ -72,7 +73,7 @@ import { APPROACHES, rank, scoreCandidate, summarizeTournament } from '../naruto
 export async function runNativeAgentOrchestrator(opts = {}) {
     const root = path.resolve(opts.root || process.cwd());
     const sessionKey = opts.sessionKey || null;
-    const prompt = String(opts.prompt || 'Native agent run');
+    const prompt = await resolveAgentMissionPrompt(root, opts);
     const route = opts.route || '$Agent';
     const routeCommand = String(opts.routeCommand || defaultRouteCommand(route));
     const routeBlackboxKind = String(opts.routeBlackboxKind || defaultRouteBlackboxKind(route));
@@ -412,7 +413,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
                 generationIndex: agent.generation_index,
                 requireGeneration: true
             });
-            const backendOpts = { ...opts, missionId, agentRoot: ledgerRoot, cwd: workerWorktree?.context.path || root, projectRoot: root, route, prompt, fastMode: fastModePolicy.fast_mode, serviceTier: fastModePolicy.service_tier, ...(workerWorktree ? { worktree: workerWorktree.context } : {}) };
+            const backendOpts = { ...opts, missionId, agentRoot: ledgerRoot, cwd: workerWorktree?.context.path || root, projectRoot: root, projectHash: namespace.root_hash, route, prompt, fastMode: fastModePolicy.fast_mode, serviceTier: fastModePolicy.service_tier, ...(workerWorktree ? { worktree: workerWorktree.context } : {}) };
             const result = opts.nativeCliSwarm === false
                 ? await runAgentByBackend(backend, runtimeAgent, runtimeSlice, backendOpts)
                 : await nativeCliSwarm.launchWorker({ agent: runtimeAgent, slice: runtimeSlice, opts: backendOpts });
@@ -684,6 +685,27 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         proof
     };
 }
+export async function resolveAgentMissionPrompt(root, opts) {
+    const direct = String(opts.prompt || '').trim();
+    if (opts.promptExplicit === true || (direct && direct !== 'Native agent run'))
+        return direct || 'Native agent run';
+    const missionId = String(opts.missionId || '').trim();
+    if (!missionId)
+        return direct || 'Native agent run';
+    const dir = missionDir(root, missionId);
+    const [intake, routeContext, mission] = await Promise.all([
+        readJson(path.join(dir, 'request-intake.json'), null),
+        readJson(path.join(dir, 'route-context.json'), null),
+        readJson(path.join(dir, 'mission.json'), null)
+    ]);
+    return String(intake?.transformed_prompt
+        || routeContext?.transformed_prompt
+        || routeContext?.task
+        || routeContext?.prompt
+        || mission?.prompt
+        || direct
+        || 'Native agent run').trim();
+}
 function normalizeMissionHardTimeoutMs(opts = {}, route = '') {
     const raw = Number(opts.hardTimeoutMs || opts.agentHardTimeoutMs || process.env.SKS_AGENT_HARD_TIMEOUT_MS || 0);
     if (Number.isFinite(raw) && raw > 0)
@@ -1905,7 +1927,7 @@ function buildProvidedAgentRoster(input, opts = {}) {
             writePolicy: String(entry.write_policy || '')
         });
         const suppliedModelEffort = String(entry.model_reasoning_effort || '');
-        const modelReasoningEffort = suppliedModelEffort === 'low' || suppliedModelEffort === 'high'
+        const modelReasoningEffort = ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'].includes(suppliedModelEffort)
             ? suppliedModelEffort
             : modelDecision.model_reasoning_effort;
         return {
@@ -1989,7 +2011,7 @@ async function runAgentByBackend(backend, agent, slice, opts) {
             zellijPaneId: null,
             reliabilityPolicy: {
                 maxEmptyResultRetries: writePaths.length ? 1 : 2,
-                timeoutClass: writePaths.length ? 'standard' : 'short'
+                timeoutClass: codexTimeoutClassForRoute(opts.route, writePaths.length ? 'standard' : 'short')
             }
         });
         const sdkWorkerResult = await readJson(sdkTask.workerResultPath, null);

package/dist/core/agents/agent-output-validator.js

@@ -34,7 +34,7 @@ export const AGENT_RESULT_RUNTIME_SCHEMA = {
         task_slice_id: { type: 'string' },
         work_item_kind: { type: 'string' },
         status: { enum: ['done', 'blocked', 'failed'] },
-        backend: { enum: ['fake', 'process', 'codex-sdk', 'python-codex-sdk', 'zellij', 'ollama', 'local-llm'] },
+        backend: { enum: ['fake', 'process', 'codex-sdk', 'python-codex-sdk', 'codex-exec', 'zellij', 'tmux', 'ollama', 'local-llm'] },
         summary: { type: 'string' },
         findings: { type: 'array', items: { type: 'string' } },
         proposed_changes: { type: 'array', items: { type: 'string' } },

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

@@ -321,7 +321,7 @@ export async function writeAgentProofEvidence(root, input) {
         patch_conflict_count: patchConflictCount,
         serial_bottleneck_count: serialBottleneckCount,
         changed_files_by_agent: changedFilesByAgent(patchApplyRows, patchEntries),
-        lease_compliance_by_patch: leaseComplianceByPatch(patchEntries, input.partition?.leases || []),
+        lease_compliance_by_patch: leaseComplianceByPatch(patchEntries, input.partition?.leases || [], patchProof),
         rollback_digest_count: patchApplyRows.filter((row) => row.rollback_digest).length,
         real_parallel_claim: input.realParallel === true && input.backend === 'codex-sdk',
         fake_backend_disclaimer: input.backend === 'fake' ? 'fixture only; no real parallel execution claim' : null,
@@ -459,7 +459,21 @@ function changedFilesByAgent(applyRows, queueEntries) {
     }
     return out;
 }
-function leaseComplianceByPatch(queueEntries, leases) {
+export function leaseComplianceByPatch(queueEntries, leases, patchProof) {
+    if (Array.isArray(patchProof?.lease_compliance_by_patch)) {
+        const entriesById = new Map(queueEntries.map((entry) => [String(entry.id), entry]));
+        return patchProof.lease_compliance_by_patch.map((row) => {
+            const patchEntryId = String(row.patch_entry_id || row.entry_id || '');
+            const entry = entriesById.get(patchEntryId);
+            return {
+                patch_entry_id: patchEntryId,
+                agent_id: entry?.envelope?.agent_id || row.agent_id || null,
+                lease_id: row.lease_id || null,
+                ok: row.ok === true,
+                write_paths: Array.isArray(row.write_paths) ? row.write_paths.map(String) : []
+            };
+        });
+    }
     return queueEntries.map((entry) => {
         const leaseId = entry.envelope?.lease_id || entry.envelope?.lease_proof?.lease_id || null;
         const agentId = entry.envelope?.agent_id || null;

package/dist/core/agents/agent-role-config.js

@@ -32,7 +32,7 @@ export async function repairAgentRoleConfigs(input) {
         let managedCopyFound = false;
         for (const foundPath of foundPaths) {
             const text = fs.readFileSync(foundPath, 'utf8');
-            if (isValidRoleConfig(text, role)) {
+            if (isValidRoleConfig(text, content)) {
                 managedCopyFound = true;
                 existing.push(path.relative(root, foundPath) || foundPath);
                 continue;
@@ -78,10 +78,7 @@ export async function repairAgentRoleConfigs(input) {
         await writeJsonAtomic(input.reportPath, report);
     return report;
 }
-function isValidRoleConfig(text, role) {
-    return managedAgentRoleOwnsText(text, role)
-        && text.includes('description = "')
-        && text.includes('developer_instructions = """')
-        && !/^\s*(?:model|model_reasoning_effort)\s*=/m.test(text);
+function isValidRoleConfig(text, expected) {
+    return text === expected;
 }
 //# sourceMappingURL=agent-role-config.js.map

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

@@ -151,8 +151,8 @@ export function buildNarutoCloneRoster(opts = {}) {
         const cloneReadonly = readonly || !writeAllowed;
         const role = mapNarutoRoleToAgentRole(narutoRole);
         const allowedTools = writeAllowed ? ['read', 'search', 'edit', 'test'] : narutoRole === 'verifier' ? ['read', 'search', 'test'] : ['read', 'search'];
-        // Dynamic per-clone effort like team mode, capped at low/medium and always fast.
-        const effort = decideNarutoCloneEffort({ persona: { ...base, role, allowed_tools: allowedTools, read_only: cloneReadonly, write_policy: writeAllowed ? 'exclusive Naruto patch-envelope lease required' : 'read-only Naruto role' }, prompt: opts.prompt || '', agentId: id, readonly: cloneReadonly });
+        // Dynamic Naruto-only GPT-5.6 model/effort policy; there is no legacy low/medium cap.
+        const effort = decideNarutoCloneEffort({ persona: { ...base, role, naruto_role: narutoRole, allowed_tools: allowedTools, read_only: cloneReadonly, write_policy: writeAllowed ? 'exclusive Naruto patch-envelope lease required' : 'read-only Naruto role' }, prompt: opts.prompt || '', agentId: id, readonly: cloneReadonly });
         const persona = {
             ...base,
             id,

package/dist/core/agents/agent-runner-codex-exec.js

@@ -44,6 +44,7 @@ export async function runCodexExecAgent(agent, slice, opts = {}) {
         const command = buildCodexExecAgentArgs(agent, opts.prompt || slice?.description || '', opts);
         const proxyEnv = managedProxyEnvForChild({ ...process.env, ...(opts.env || {}) });
         const report = await writeCodexProcessReport(opts.agentRoot || opts.cwd || process.cwd(), agent, {
+            project_hash: opts.projectHash || agent.project_hash || agent.root_hash || null,
             command: [opts.codexBin || 'codex', ...command.args],
             profile: opts.profile || null,
             result_file: command.resultFile,
@@ -74,6 +75,7 @@ export async function runCodexExecAgent(agent, slice, opts = {}) {
     const proxyEnv = managedProxyEnvForChild({ ...process.env, ...(opts.env || {}) });
     const result = await runProcess(opts.codexBin || 'codex', command.args, { cwd: opts.cwd || process.cwd(), env: { ...(opts.env || {}), ...proxyEnv, ...fastModeEnv(fastPolicy), ...workerEnv }, timeoutMs: opts.timeoutMs || 30 * 60 * 1000, maxOutputBytes: 256 * 1024, stdoutFile, stderrFile });
     const report = await writeCodexProcessReport(opts.agentRoot || opts.cwd || process.cwd(), agent, {
+        project_hash: opts.projectHash || agent.project_hash || agent.root_hash || null,
         command: [opts.codexBin || 'codex', ...command.args],
         profile: opts.profile || null,
         result_file: command.resultFile,

package/dist/core/agents/agent-runner-process.js

@@ -48,6 +48,7 @@ export async function runProcessAgent(agent, slice, opts = {}) {
     }
     const result = await runProcess(opts.command[0], opts.command.slice(1), { cwd: opts.cwd || process.cwd(), env: { ...(opts.env || {}), ...fastModeEnv(fastPolicy) }, timeoutMs: opts.timeoutMs || 30000, maxOutputBytes: 128 * 1024 });
     const report = await writeAgentProcessReport(opts.agentRoot || opts.cwd || process.cwd(), agent, 'process', {
+        project_hash: opts.projectHash || agent.project_hash || agent.root_hash || null,
         command: opts.command,
         service_tier: fastPolicy.service_tier,
         fast_mode: fastPolicy.fast_mode,

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

@@ -18,17 +18,15 @@ export function resolveFastModePolicy(input = {}) {
             ? 'standard'
             : preference?.mode === 'standard'
                 ? 'standard'
-                : explicitFast || explicitTier === 'fast' || preference?.mode === 'fast'
-                    ? 'fast'
-                    : 'standard';
+                : 'fast';
     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: false,
-        disabled_by: explicitNoFast ? 'no-fast' : explicitTier === 'standard' ? 'service-tier-standard' : preference?.mode === 'standard' ? 'preference-standard' : serviceTier === 'standard' ? 'default-standard' : 'none',
+        default_fast_mode: true,
+        disabled_by: explicitNoFast ? 'no-fast' : explicitTier === 'standard' ? 'service-tier-standard' : preference?.mode === 'standard' ? 'preference-standard' : 'none',
         explicit_fast: explicitFast,
         explicit_no_fast: explicitNoFast,
         explicit_service_tier: explicitTier,

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

@@ -13,6 +13,7 @@ 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';
+import { readCodexLbModelCatalog } from '../codex-lb/codex-lb-env.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);
@@ -26,11 +27,26 @@ class NativeCliSessionSwarmRecorder {
     writeLock = Promise.resolve();
     nextPaneToken = -1;
     visibleZellijReservations = new Set();
+    narutoModelCatalog = null;
     constructor(root, input) {
         this.root = root;
         this.input = input;
     }
     async initialize() {
+        if (/\$?naruto/i.test(this.input.route) && (this.input.backend === 'codex-sdk' || this.input.backend === 'zellij')) {
+            this.narutoModelCatalog = await readCodexLbModelCatalog().catch(() => ({
+                schema: 'sks.codex-lb-model-catalog.v1',
+                ok: false,
+                status: 'blocked',
+                models: [],
+                model_efforts: {},
+                blockers: ['codex_lb_model_catalog_unavailable']
+            }));
+            if (this.narutoModelCatalog?.ok !== true) {
+                const blockers = Array.isArray(this.narutoModelCatalog?.blockers) ? this.narutoModelCatalog.blockers.join(',') : 'unavailable';
+                throw new Error(`naruto_model_catalog_preflight_failed:${blockers}`);
+            }
+        }
         await this.persist();
     }
     async launchWorker(ctx) {
@@ -72,7 +88,8 @@ class NativeCliSessionSwarmRecorder {
             source_intelligence_refs: ctx.agent.source_intelligence_refs || null,
             goal_mode_ref: ctx.agent.goal_mode_ref || null,
             strategy_refs: ctx.slice?.strategy_refs || null,
-            recursion_guard_env: true
+            recursion_guard_env: true,
+            naruto_model_catalog: this.narutoModelCatalog
         };
         await writeJsonAtomic(path.join(this.root, intakeRel), intake);
         const cliPath = await resolveWorkerCliPath();