sneakoscope 10.3.2 → 10.3.4

package/dist/core/decisions/policy.js

@@ -1,4 +1,4 @@
-import { CHOICE_MIN_CONFIDENCE, CHOICE_MIN_PROBABILITY, CONTEXT_DROP_NOUL_MAX, DISTRIBUTION_SUM_TOLERANCE, KEEP_BASELINE_CHOICE, NEEDS_EVIDENCE_CHOICE, POLICY_REVISION, ROUTING_RISK_NOUL_MIN, ROUTING_ROLE_OMIT_NOUL_MAX, UNKNOWN_USAGE, sealedRoutingModel } from './types.js';
+import { CHOICE_MIN_CONFIDENCE, CHOICE_MIN_PROBABILITY, CONTEXT_DROP_NOUL_MAX, DISTRIBUTION_SUM_TOLERANCE, DELEGATION_CHOICES, KEEP_BASELINE_CHOICE, NEEDS_EVIDENCE_CHOICE, POLICY_REVISION, ROUTING_RISK_NOUL_MIN, ROUTING_ROLE_OMIT_NOUL_MAX, UNKNOWN_USAGE, ESCALATION_ROUTING_TIER, routingTier } from './types.js';
 export function compileDecision(bundle, response) {
     const usage = usageFromWire(response.usage);
     const decoded = decodeWireResponse(bundle, response);
@@ -33,6 +33,14 @@ export function compileDecision(bundle, response) {
         else if (!fallbackReason)
             fallbackReason = compiled.reason;
     }
+    const delegationBinding = Object.entries(bundle.questionBindings).find(([, binding]) => binding.kind === 'delegation');
+    if (delegationBinding) {
+        const compiled = compileDelegation(decoded.response.answers[delegationBinding[0]]);
+        if (compiled.kind === 'effect')
+            effects.push(compiled.effect);
+        else if (!fallbackReason)
+            fallbackReason = compiled.reason;
+    }
     if (effects.length === 0) {
         return {
             kind: 'keep_baseline',
@@ -172,7 +180,7 @@ function compileRoleRouting(bundle, answers, roleId) {
         return { kind: 'baseline', reason: 'invalid_response' };
     if (answer.choice === KEEP_BASELINE_CHOICE)
         return { kind: 'baseline', reason: 'keep_baseline_selected' };
-    const selected = sealedRoutingModel(answer.choice);
+    const selected = routingTier(answer.choice);
     if (!selected)
         return { kind: 'baseline', reason: 'invalid_response' };
     const choiceQuestion = choiceId ? bundle.request.questions[choiceId] : undefined;
@@ -180,8 +188,8 @@ function compileRoleRouting(bundle, answers, roleId) {
     const uncertainty = requiredChoiceUncertainty(answer, labels);
     if (!uncertainty.ok)
         return { kind: 'baseline', reason: uncertainty.reason };
-    const model = escalateRole(bundle, answers, roleId) ? 'gpt-6-astra' : selected.id;
-    return { kind: 'effect', effect: { kind: 'select_routing', roleId, model } };
+    const tier = escalateRole(bundle, answers, roleId) ? ESCALATION_ROUTING_TIER : selected.id;
+    return { kind: 'effect', effect: { kind: 'select_routing', roleId, tier } };
 }
 function escalateRole(bundle, answers, roleId) {
     const difficultyId = questionIdFor(bundle, 'routing_difficulty', roleId);
@@ -264,6 +272,21 @@ function compileRecovery(bundle, answer) {
         return { kind: 'baseline', reason: uncertainty.reason };
     return { kind: 'effect', effect: { kind: 'dispatch_recovery', actionId: candidate.id } };
 }
+function compileDelegation(answer) {
+    if (!answer)
+        return { kind: 'baseline', reason: 'missing_answer' };
+    if (answer.type !== 'choice')
+        return { kind: 'baseline', reason: 'invalid_response' };
+    if (answer.choice === KEEP_BASELINE_CHOICE)
+        return { kind: 'baseline', reason: 'keep_baseline_selected' };
+    const choice = DELEGATION_CHOICES.find((row) => row === answer.choice);
+    if (!choice)
+        return { kind: 'baseline', reason: 'invalid_response' };
+    const uncertainty = requiredChoiceUncertainty(answer, [...DELEGATION_CHOICES, KEEP_BASELINE_CHOICE]);
+    if (!uncertainty.ok)
+        return { kind: 'baseline', reason: uncertainty.reason };
+    return { kind: 'effect', effect: { kind: 'select_delegation', choice } };
+}
 function canDropOptional(candidate, noul) {
     return !candidate.pinned
         && candidate.fresh

package/dist/core/decisions/questions.js

@@ -1,4 +1,4 @@
-import { CONTEXT_RELEVANCE_RUBRIC, DESIGN_DEFAULTS, KEEP_BASELINE_CHOICE, NEEDS_EVIDENCE_CHOICE, QUESTION_REVISION, ROUTING_DIFFICULTY_RUBRIC, SEALED_ROUTING_MODELS } from './types.js';
+import { CONTEXT_RELEVANCE_RUBRIC, DELEGATION_CHOICES, DESIGN_DEFAULTS, KEEP_BASELINE_CHOICE, NEEDS_EVIDENCE_CHOICE, QUESTION_REVISION, ROUTING_DIFFICULTY_RUBRIC, ROUTING_TIERS } from './types.js';
 import { buildDecisionBinding, redactDecisionText } from './state.js';
 const SAME_BATCH_DEPENDENCY = /\b(selected above|answer above|previous answer|the (plan|action) selected|if the (plan|action) selected)\b/i;
 export const CONTEXT_RELEVANCE_LEVELS = CONTEXT_RELEVANCE_RUBRIC.length;
@@ -33,6 +33,7 @@ export function buildDecisionBundle(input) {
     const contextCandidates = [...(input.contextCandidates || [])];
     const recoveryCandidates = [...(input.recoveryCandidates || [])];
     const routingCandidates = [...(input.routingCandidates || [])];
+    const delegationCandidate = input.delegationCandidate || null;
     const questions = {};
     const questionBindings = {};
     const recoverySlot = recoveryCandidates.length > 0 ? 1 : 0;
@@ -50,6 +51,7 @@ export function buildDecisionBundle(input) {
         questionBindings.plan = { kind: 'plan' };
     }
     const routedRoles = appendRoutingChoices(routingCandidates, questions, questionBindings, recoverySlot);
+    appendDelegationChoice(delegationCandidate, questions, questionBindings, recoverySlot);
     for (const candidate of contextCandidates.filter((row) => !row.pinned && row.excerpt)) {
         if (Object.keys(questions).length + 2 > DESIGN_DEFAULTS.maxQuestions - recoverySlot)
             break;
@@ -123,8 +125,16 @@ export function buildDecisionBundle(input) {
             diagnostic: redactDecisionText(input.recoveryDiagnostic || '', 800),
             handlers: recoveryCandidates
         },
+        delegation: delegationCandidate
+            ? {
+                tool: redactDecisionText(delegationCandidate.toolName, 120),
+                targets: delegationCandidate.targets.slice(0, 16).map((target) => redactDecisionText(target, 240)),
+                mission_goal: redactDecisionText(delegationCandidate.missionGoal, 800),
+                children_started: 0
+            }
+            : null,
         routing: {
-            models: Object.fromEntries(SEALED_ROUTING_MODELS.map((row) => [row.id, {
+            tiers: Object.fromEntries(ROUTING_TIERS.map((row) => [row.id, {
                     effort: row.effort,
                     summary: row.summary
                 }])),
@@ -146,7 +156,7 @@ export function buildDecisionBundle(input) {
             workflowRevision: input.workflowRevision,
             sourceDigest: input.sourceDigest,
             graphDigest: input.graphDigest,
-            candidates: { planCandidates, contextCandidates, recoveryCandidates, routingCandidates: routedRoles },
+            candidates: { planCandidates, contextCandidates, recoveryCandidates, routingCandidates: routedRoles, delegationCandidate },
             questions,
             requestedModel: DESIGN_DEFAULTS.model
         }),
@@ -155,6 +165,7 @@ export function buildDecisionBundle(input) {
         contextCandidates,
         recoveryCandidates,
         routingCandidates: routedRoles,
+        delegationCandidate,
         baselinePlanId: input.baselinePlanId ?? planCandidates[0]?.id ?? null,
         questionBindings
     };
@@ -168,14 +179,14 @@ function appendRoutingChoices(roles, questions, bindings, recoverySlot) {
         if (questionRoom(questions, recoverySlot) < 1)
             break;
         const id = `route_${role.id}`;
-        const instructions = redactDecisionText(`Choose the sealed model for routing.roles.${role.id} using state.task and that role summary. Prefer the fastest sealed model that can do the work. Use gpt-6-astra for judgment, ambiguity, or high-stakes work. Select ${KEEP_BASELINE_CHOICE} when the work is not distinguished. Do not invent a model.`);
+        const instructions = redactDecisionText(`Choose the model tier for routing.roles.${role.id} using state.task and that role summary. Each tier is the newest model for that speed and accuracy. Prefer the fastest tier that can do the work correctly. Use deep for judgment, ambiguity, or high-stakes work. Select ${KEEP_BASELINE_CHOICE} when the work is not distinguished. Do not invent a tier.`);
         assertIndependentQuestion(instructions);
         questions[id] = {
             type: 'choice',
             instructions,
             criteria: {
-                ...Object.fromEntries(SEALED_ROUTING_MODELS.map((row) => [row.id, row.summary])),
-                [KEEP_BASELINE_CHOICE]: 'The role work is not distinguished enough to leave the baseline model.'
+                ...Object.fromEntries(ROUTING_TIERS.map((row) => [row.id, row.summary])),
+                [KEEP_BASELINE_CHOICE]: 'The role work is not distinguished enough to leave the baseline tier.'
             }
         };
         bindings[id] = { kind: 'routing', roleId: role.id };
@@ -183,6 +194,25 @@ function appendRoutingChoices(roles, questions, bindings, recoverySlot) {
     }
     return included;
 }
+function appendDelegationChoice(candidate, questions, bindings, recoverySlot) {
+    if (!candidate || questionRoom(questions, recoverySlot) < 1)
+        return;
+    const instructions = redactDecisionText(`state.delegation describes a tool call the Naruto parent thread wants to make before any child thread exists. Using state.task, state.delegation.tool, and state.delegation.targets, choose whether that edit is slice implementation that a child must own, or orchestration scaffolding that no slice owns and that children depend on (a shared interface or type stub, workspace or build wiring, or a plan file). Any change to feature, fix, or test code is slice work, however small. Select ${KEEP_BASELINE_CHOICE} when the evidence does not distinguish them.`);
+    assertIndependentQuestion(instructions);
+    questions.delegation = {
+        type: 'choice',
+        instructions,
+        criteria: {
+            ...Object.fromEntries(DELEGATION_CHOICES.map((choice) => [choice, DELEGATION_CHOICE_SUMMARIES[choice]])),
+            [KEEP_BASELINE_CHOICE]: 'The evidence does not distinguish orchestration scaffolding from slice work.'
+        }
+    };
+    bindings.delegation = { kind: 'delegation' };
+}
+const DELEGATION_CHOICE_SUMMARIES = Object.freeze({
+    delegate_child: 'The edit implements assigned slice work. The parent must spawn a child for it first.',
+    parent_owned: 'The edit is orchestration scaffolding that no slice owns and that children depend on.'
+});
 function appendRoutingSpeculation(roles, questions, bindings, recoverySlot) {
     for (const role of roles) {
         if (questionRoom(questions, recoverySlot) < 1)
@@ -199,14 +229,14 @@ function appendRoutingSpeculation(roles, questions, bindings, recoverySlot) {
         if (questionRoom(questions, recoverySlot) < 1)
             break;
         const riskId = `risk_${role.id}`;
-        const riskInstructions = redactDecisionText(`Does routing.roles.${role.id} need gpt-6-astra because the work is high-stakes, ambiguous, or unsafe on a faster sealed model?`);
+        const riskInstructions = redactDecisionText(`Does routing.roles.${role.id} need the deep tier because the work is high-stakes, ambiguous, or unsafe on a faster tier?`);
         assertIndependentQuestion(riskInstructions);
         questions[riskId] = {
             type: 'noul',
             instructions: riskInstructions,
             criteria: {
-                true: 'The work needs the most capable sealed model.',
-                false: 'A faster sealed model can do this work.'
+                true: 'The work needs the most capable latest model.',
+                false: 'A faster latest model can do this work.'
             }
         };
         bindings[riskId] = { kind: 'routing_risk', roleId: role.id };

package/dist/core/decisions/routing.js

@@ -1,4 +1,5 @@
-import { sealedRoutingModel } from './types.js';
+import { effortForTier, latestTierModelSet, resolveLatestModelTiers } from '../subagents/model-tiers.js';
+import { routingTier } from './types.js';
 const ROLE_ID = /^[a-z][a-z0-9_]{0,40}$/;
 export const MAX_JEV_ROUTING_ROLES = 8;
 export function buildRoutingCandidates(input) {
@@ -19,17 +20,17 @@ export function applySealedRouting(agents, selected) {
     if (!selected || !agents)
         return { ...(agents || {}) };
     const next = { ...agents };
+    const current = latestTierModelSet();
     for (const [name, effort] of Object.entries(selected.efforts)) {
         const model = selected.models[name];
-        const sealed = model ? sealedRoutingModel(model) : null;
-        if (!sealed || sealed.effort !== effort)
+        if (!model || !current.has(model))
             continue;
         const row = next[name];
         if (!row || row.routing_dynamic !== true || row.routed_model_policy === 'user_role_model_preference')
             continue;
         next[name] = {
             ...row,
-            routed_model: sealed.id,
+            routed_model: model,
             routed_model_reasoning_effort: effort,
             routed_model_policy: 'jev_sealed_routing',
             jev_routing_lane: selected.id
@@ -38,21 +39,25 @@ export function applySealedRouting(agents, selected) {
     return next;
 }
 export function assembleRoutingSelection(effects) {
+    const resolved = resolveLatestModelTiers();
     const models = {};
     const efforts = {};
+    const tiers = {};
     for (const effect of effects) {
-        const sealed = sealedRoutingModel(effect.model);
-        if (!sealed || !ROLE_ID.test(effect.roleId))
+        const tier = routingTier(effect.tier);
+        if (!tier || !ROLE_ID.test(effect.roleId))
             continue;
-        models[effect.roleId] = sealed.id;
-        efforts[effect.roleId] = sealed.effort;
+        models[effect.roleId] = resolved.models[tier.id];
+        efforts[effect.roleId] = effortForTier(tier.id, resolved);
+        tiers[effect.roleId] = tier.id;
     }
     if (Object.keys(models).length === 0)
         return null;
     return {
         id: 'jev_role_fanout',
-        summary: 'Jev chose a sealed model for each dynamic Naruto role.',
+        summary: 'Jev chose a tier for each dynamic Naruto role; each tier is its newest model.',
         models,
-        efforts
+        efforts,
+        tiers
     };
 }

package/dist/core/decisions/types.js

@@ -1,25 +1,14 @@
-export const SEALED_ROUTING_MODELS = Object.freeze([
-    Object.freeze({
-        id: 'gpt-5.6-luna',
-        effort: 'low',
-        summary: 'Fastest sealed model. Mechanical edits, renames, formatting, and other one-step changes.'
-    }),
-    Object.freeze({
-        id: 'gpt-5.6-sol',
-        effort: 'low',
-        summary: 'Fast sealed model. Simple coding whose result is already specified.'
-    }),
-    Object.freeze({
-        id: 'gpt-5.6-terra',
-        effort: 'medium',
-        summary: 'Context and tools. Search, multi-file reading, and broad exploration.'
-    }),
-    Object.freeze({
-        id: 'gpt-6-astra',
-        effort: 'max',
-        summary: 'Escalate. Judgment, architecture, ambiguity, security, or high-stakes work.'
-    })
+export const ROUTING_TIERS = Object.freeze([
+    Object.freeze({ id: 'fast', effort: 'low', summary: 'Fastest latest model. Mechanical edits, renames, formatting, and other one-step changes.' }),
+    Object.freeze({ id: 'balanced', effort: 'low', summary: 'Fast latest model. Simple coding whose result is already specified.' }),
+    Object.freeze({ id: 'context', effort: 'medium', summary: 'Latest model for context and tools. Search, multi-file reading, and broad exploration.' }),
+    Object.freeze({ id: 'deep', effort: 'max', summary: 'Escalate to the most capable latest model. Judgment, architecture, ambiguity, security, or high-stakes work.' })
 ]);
+export const ESCALATION_ROUTING_TIER = 'deep';
+export function routingTier(value) {
+    const match = ROUTING_TIERS.find((row) => row.id === value);
+    return match ? { id: match.id, effort: match.effort } : null;
+}
 export const ROUTING_DIFFICULTY_RUBRIC = Object.freeze([
     'Mechanical one-step work: rename, format, copy, or a single exact edit.',
     'Simple coding whose result is already specified.',
@@ -28,10 +17,7 @@ export const ROUTING_DIFFICULTY_RUBRIC = Object.freeze([
 ]);
 export const ROUTING_RISK_NOUL_MIN = 0.70;
 export const ROUTING_ROLE_OMIT_NOUL_MAX = 0.35;
-export function sealedRoutingModel(model) {
-    const match = SEALED_ROUTING_MODELS.find((row) => row.id === model);
-    return match ? { id: match.id, effort: match.effort } : null;
-}
+export const DELEGATION_CHOICES = Object.freeze(['delegate_child', 'parent_owned']);
 export const DESIGN_DEFAULTS = Object.freeze({
     mode: 'off',
     model: 'typesafe/jev-1.13',

package/dist/core/doctor/current-project-guidance.js

@@ -11,7 +11,7 @@ import { collectNestedProjectRoots } from './current-project-guidance-nested.js'
 import { escapeRegExp } from '../text/regex.js';
 export const CURRENT_PROJECT_GUIDANCE_SCHEMA = 'sks.current-project-guidance.v1';
 const AGENTS_MARKER = 'BEGIN Sneakoscope Codex GX MANAGED BLOCK';
-const RETIRED_COMMAND_NAMES = ['team', 'mad-db', 'tmux', 'xai', 'swarm', 'agent', 'ralph', 'db', 'ui', 'glm'];
+const RETIRED_COMMAND_NAMES = ['team', 'mad-db', 'tmux', 'xai', 'swarm', 'agent', 'ralph', 'loop', 'db', 'ui', 'glm'];
 const RETIRED_DOLLAR_COMMAND_NAMES = ['Agent', 'Team', 'MAD-DB', 'Swarm', 'ShadowClone', 'Kagebunshin', 'Ralph'];
 const LEGACY_UNPREFIXED_DOLLAR_COMMAND_NAMES = Array.from(new Set([
     ...RETIRED_DOLLAR_COMMAND_NAMES,
@@ -69,6 +69,43 @@ export async function reconcileCurrentProjectGuidance(opts) {
         warnings: counters.warnings
     };
 }
+export async function reconcileManagedProjectPromptGuidance(root) {
+    const projectRoot = path.resolve(root);
+    const refreshed = [];
+    let errors = 0;
+    const agentsFile = path.join(projectRoot, 'AGENTS.md');
+    const agentsStat = await fsp.lstat(agentsFile).catch(() => null);
+    if (agentsStat?.isFile() && !agentsStat.isSymbolicLink()) {
+        const before = await readText(agentsFile, '');
+        if (before.includes(AGENTS_MARKER) && managedAgentsBlockNeedsReconcile(before)) {
+            try {
+                await mergeManagedBlock(agentsFile, 'Sneakoscope Codex GX MANAGED BLOCK', agentsBlockText());
+                refreshed.push('AGENTS.md');
+            }
+            catch {
+                errors += 1;
+            }
+        }
+    }
+    const quickFile = path.join(projectRoot, '.codex', 'SNEAKOSCOPE.md');
+    const quickStat = await fsp.lstat(quickFile).catch(() => null);
+    if (quickStat?.isFile() && !quickStat.isSymbolicLink()) {
+        const before = await readText(quickFile, '');
+        if (isManagedQuickReference(before)) {
+            const expected = codexAppQuickReference(quickReferenceInstallScope(before, 'project'), quickReferenceCommandPrefix(before, 'project'));
+            if (before !== expected) {
+                try {
+                    await writeTextAtomic(quickFile, expected);
+                    refreshed.push('.codex/SNEAKOSCOPE.md');
+                }
+                catch {
+                    errors += 1;
+                }
+            }
+        }
+    }
+    return { refreshed, errors };
+}
 async function reconcileGuidanceScope(scope, fix, runId, counters) {
     const rootStat = await fsp.lstat(scope.root).catch((error) => error?.code === 'ENOENT' ? null : Promise.reject(error));
     if (!rootStat)

package/dist/core/doctor/skill-legacy-surface.js

@@ -31,7 +31,8 @@ const REWRITE_RULES = [
     { id: 'cli-team', pattern: new RegExp(`${LEFT}sks\\s+team${RIGHT}`, 'gi'), replace: '$1sks naruto' },
     { id: 'cli-agent', pattern: new RegExp(`${LEFT}sks\\s+agent${RIGHT}`, 'gi'), replace: '$1sks naruto' },
     { id: 'cli-swarm', pattern: new RegExp(`${LEFT}sks\\s+swarm${RIGHT}`, 'gi'), replace: '$1sks naruto' },
-    { id: 'cli-ralph', pattern: new RegExp(`${LEFT}sks\\s+ralph${RIGHT}`, 'gi'), replace: '$1sks loop' },
+    { id: 'cli-ralph', pattern: new RegExp(`${LEFT}sks\\s+ralph${RIGHT}`, 'gi'), replace: '$1sks naruto' },
+    { id: 'cli-loop', pattern: new RegExp(`${LEFT}sks\\s+loop${RIGHT}`, 'gi'), replace: '$1sks naruto' },
     { id: 'cli-tmux', pattern: new RegExp(`${LEFT}sks\\s+tmux${RIGHT}`, 'gi'), replace: '$1sks --mad' },
     { id: 'cli-xai', pattern: new RegExp(`${LEFT}sks\\s+xai${RIGHT}`, 'gi'), replace: '$1sks bridge provider configure openrouter --api-key-stdin' },
     { id: 'cli-glm', pattern: new RegExp(`${LEFT}sks\\s+glm${RIGHT}`, 'gi'), replace: '$1sks bridge provider configure openrouter --api-key-stdin' },

package/dist/core/hooks-runtime/hook-context.js

@@ -19,7 +19,7 @@ const OFFICIAL_SUBAGENT_SPAWN_COMPATIBILITY_CONTEXT = [
     'SKS Codex 0.145 official-subagent spawn compatibility:',
     '- Full-history forks (`fork_turns="all"`, including the omitted/default full-history mode) inherit the parent agent type, model, and reasoning effort.',
     '- When selecting a custom `agent_type` or overriding `model`/`reasoning_effort`, set `fork_turns="none"` or a positive bounded turn count and put the complete bounded slice contract in `message`.',
-    '- SKS children must use explicit `model=\"gpt-6-astra\"`, task-appropriate `reasoning_effort`, and `fork_turns=\"none\"` or a positive bounded turn count. Do not use omitted/default or full-history forks, which can inherit a non-Astra parent.'
+    '- SKS children must pass the slice contract `model` (the newest model of the role tier), its `reasoning_effort`, and `fork_turns=\"none\"` or a positive bounded turn count. When Jev mode is on, the SKS PreToolUse hook seals Jev\'s tier on every spawn, so do not tune model or effort yourself. A stored user role-model preference wins. Do not use omitted/default or full-history forks, which inherit the parent model.'
 ].join('\n');
 export function officialSubagentSpawnCompatibilityContext() {
     return OFFICIAL_SUBAGENT_SPAWN_COMPATIBILITY_CONTEXT;

package/dist/core/hooks-runtime/jev-spawn-routing.js

@@ -1,4 +1,7 @@
 import { consultJevTurnModel } from '../decisions/integration.js';
+import { managedOfficialSubagentRoleByName } from '../managed-assets/managed-assets-manifest.js';
+import { subagentModelProfile } from '../subagents/model-policy.js';
+import { effortForTier, latestModelForTier, latestTierModelSet } from '../subagents/model-tiers.js';
 import { readRoleModelPreferences } from '../subagents/role-model-preferences.js';
 const SPAWN_TOOLS = new Set(['spawn_agent', 'collaboration.spawn_agent', 'functions.spawn_agent']);
 function spawnInput(payload) {
@@ -22,6 +25,14 @@ function spawnTask(input) {
         .join('\n')
         .slice(0, 1200);
 }
+export function roleTierFallback(agentType) {
+    const role = agentType ? managedOfficialSubagentRoleByName(agentType) : null;
+    if (role?.model_policy) {
+        const profile = subagentModelProfile(role.model_policy);
+        return { model: profile.model, effort: effortForTier(profile.tier) };
+    }
+    return { model: latestModelForTier('deep'), effort: effortForTier('deep') };
+}
 export async function jevSpawnModelRewrite(root, state, payload) {
     if (!narutoParent(state))
         return null;
@@ -38,13 +49,21 @@ export async function jevSpawnModelRewrite(root, state, payload) {
     if (!task)
         return null;
     const decision = await consultJevTurnModel({ root, prompt: task, roleId: 'spawn' }).catch(() => null);
-    if (!decision?.model || !decision.effort)
+    if (!decision?.called)
         return null;
+    const forkTurns = input.fork_turns === undefined ? { fork_turns: 'none' } : {};
+    if (!decision.model || !decision.effort) {
+        if (latestTierModelSet().has(String(input.model || '')))
+            return null;
+        const fallback = roleTierFallback(agent);
+        return { ...input, model: fallback.model, reasoning_effort: fallback.effort, ...forkTurns };
+    }
     if (input.model === decision.model && input.reasoning_effort === decision.effort)
         return null;
     return {
         ...input,
         model: decision.model,
-        reasoning_effort: decision.effort
+        reasoning_effort: decision.effort,
+        ...forkTurns
     };
 }

package/dist/core/hooks-runtime/managed-guidance-preflight.js

@@ -0,0 +1,30 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { nowIso, PACKAGE_VERSION, readJson, writeJsonAtomic } from '../fsx.js';
+import { ensureConfinedDirectory } from '../managed-path-safety.js';
+import { reconcileManagedProjectPromptGuidance } from '../doctor/current-project-guidance.js';
+export const MANAGED_GUIDANCE_STAMP_SCHEMA = 'sks.managed-guidance-generation.v1';
+export function managedGuidanceStampPath(root) {
+    return path.join(root, '.sneakoscope', 'state', 'managed-guidance-generation.json');
+}
+export async function maybeReconcileManagedGuidancePreflight(root) {
+    const projectRoot = path.resolve(root);
+    const stampPath = managedGuidanceStampPath(projectRoot);
+    const stamp = await readJson(stampPath, null).catch(() => null);
+    if (stamp?.schema === MANAGED_GUIDANCE_STAMP_SCHEMA && stamp?.version === PACKAGE_VERSION)
+        return null;
+    const sksDir = await fsp.lstat(path.join(projectRoot, '.sneakoscope')).catch(() => null);
+    if (!sksDir?.isDirectory() || sksDir.isSymbolicLink())
+        return null;
+    const report = await reconcileManagedProjectPromptGuidance(projectRoot);
+    if (report.errors > 0)
+        return { refreshed: report.refreshed };
+    await ensureConfinedDirectory(projectRoot, path.dirname(stampPath));
+    await writeJsonAtomic(stampPath, {
+        schema: MANAGED_GUIDANCE_STAMP_SCHEMA,
+        version: PACKAGE_VERSION,
+        refreshed: report.refreshed,
+        checked_at: nowIso()
+    });
+    return { refreshed: report.refreshed };
+}

package/dist/core/hooks-runtime/official-subagent-lifecycle.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { appendJsonl, nowIso, readJson, sha256, writeJsonAtomic } from '../fsx.js';
 import { missionDir, updateCurrentIfMissionAndRun } from '../mission.js';
 import { ensureConfinedDirectory } from '../managed-path-safety.js';
-import { NARUTO_PARENT_EFFORT, NARUTO_PARENT_MODEL } from '../subagents/model-policy.js';
+import { NARUTO_PARENT_EFFORT, narutoParentModel } from '../subagents/model-policy.js';
 import { officialSubagentRolePlan } from '../subagents/agent-catalog.js';
 import { bindTrustworthySubagentParentSummaryToRun, normalizeSubagentEvent, normalizeSubagentParentSummary, persistOrReuseTrustworthySubagentParentSummary, readSubagentEvents, recordSubagentEvent, SUBAGENT_EVIDENCE_FILENAME, SUBAGENT_PARENT_SUMMARY_FILENAME, writeSubagentEvidence } from '../subagents/subagent-evidence.js';
 import { officialSubagentPreparationInProgress, SUBAGENT_LIFECYCLE_CAPTURE_FAILURE_DIR, withOfficialSubagentLifecycleLock, writeNarutoGate } from '../subagents/official-subagent-preparation.js';
@@ -308,7 +308,7 @@ async function refreshOfficialSubagentCompletionArtifactsLocked(root, state, par
     }
     const previousGate = existingGate || {};
     const parentModel = plan.observed_parent_model || state.observed_parent_model || null;
-    const parentModelMismatch = previousGate.parent_model_match === false || observedParentModelMismatch(parentModel, NARUTO_PARENT_MODEL);
+    const parentModelMismatch = previousGate.parent_model_match === false || observedParentModelMismatch(parentModel, narutoParentModel());
     const blockers = [...new Set([
             ...evidence.blockers,
             ...(Array.isArray(previousGate.config_blockers) ? previousGate.config_blockers.map(String) : []),
@@ -329,7 +329,7 @@ async function refreshOfficialSubagentCompletionArtifactsLocked(root, state, par
         route: '$Naruto',
         status: passed ? 'completed' : evidence.status,
         parent: {
-            model: NARUTO_PARENT_MODEL,
+            model: narutoParentModel(),
             model_reasoning_effort: NARUTO_PARENT_EFFORT,
             observed_model: parentModel,
             observed_model_match: parentModel ? !parentModelMismatch : null