sneakoscope 10.3.9 → 10.3.10

package/dist/core/hooks-runtime/exclusive-gui-surface-gate.js

@@ -0,0 +1,155 @@
+import path from 'node:path';
+import { readJson, writeJsonAtomic } from '../fsx.js';
+import { withFileLock } from '../locks/file-lock.js';
+import { ensureConfinedDirectory } from '../managed-path-safety.js';
+import { EXCLUSIVE_SURFACE_LABEL, exclusiveSurfaceOfRole } from '../subagents/exclusive-tool-surface.js';
+import { officialSubagentArtifactDir } from './official-subagent-lifecycle.js';
+import { isSpawnAgentToolName, spawnPayloadToolName } from './spawn-tool-name.js';
+const EXCLUSIVE_GUI_SURFACE_LEDGER_SCHEMA = 'sks.exclusive-gui-surface-ledger.v1';
+export const EXCLUSIVE_GUI_SURFACE_LEDGER_FILENAME = 'exclusive-gui-surfaces.json';
+export const PENDING_CLAIM_TTL_MS = 30_000;
+export const RUNNING_CLAIM_TTL_MS = 20 * 60_000;
+const CLAIM_REFRESH_INTERVAL_MS = 30_000;
+const ALLOW = { action: 'allow' };
+function text(value) {
+    return String(value ?? '').trim();
+}
+function spawnToolInput(payload) {
+    const input = payload?.tool_input || payload?.toolInput || payload?.tool?.input || payload?.input;
+    return input && typeof input === 'object' && !Array.isArray(input) ? input : {};
+}
+function ledgerPaths(root, sessionKey) {
+    const dir = officialSubagentArtifactDir(root, {}, sessionKey);
+    return {
+        dir,
+        file: path.join(dir, EXCLUSIVE_GUI_SURFACE_LEDGER_FILENAME),
+        lock: path.join(dir, '.exclusive-gui-surface.lock')
+    };
+}
+function validClaim(raw) {
+    return Boolean(raw)
+        && (raw.surface === 'computer_use' || raw.surface === 'browser')
+        && (raw.state === 'pending' || raw.state === 'running')
+        && (raw.agent_id === null || typeof raw.agent_id === 'string')
+        && Number.isFinite(Date.parse(raw.claimed_at))
+        && Number.isFinite(Date.parse(raw.last_seen_at));
+}
+async function readClaims(file) {
+    const raw = await readJson(file, null).catch(() => null);
+    return Array.isArray(raw?.claims) ? raw.claims.filter(validClaim) : [];
+}
+function isLive(claim, at) {
+    return claim.state === 'pending'
+        ? at - Date.parse(claim.claimed_at) <= PENDING_CLAIM_TTL_MS
+        : at - Date.parse(claim.last_seen_at) <= RUNNING_CLAIM_TTL_MS;
+}
+async function withClaims(input, change) {
+    const paths = ledgerPaths(input.root, input.sessionKey);
+    await ensureConfinedDirectory(path.resolve(input.root), paths.dir);
+    return withFileLock({ lockPath: paths.lock, timeoutMs: 5_000, staleMs: 60_000 }, async () => {
+        const at = input.now ?? Date.now();
+        const before = await readClaims(paths.file);
+        const beforeJson = JSON.stringify(before);
+        const outcome = change(before.filter((claim) => isLive(claim, at)), at);
+        if (JSON.stringify(outcome.claims) !== beforeJson) {
+            await writeJsonAtomic(paths.file, { schema: EXCLUSIVE_GUI_SURFACE_LEDGER_SCHEMA, claims: outcome.claims });
+        }
+        return outcome.result;
+    });
+}
+function denyMessage(surface, agentType, owner, at) {
+    const label = EXCLUSIVE_SURFACE_LABEL[surface];
+    const seconds = Math.max(0, Math.round((at - Date.parse(owner.claimed_at)) / 1000));
+    const who = owner.agent_id
+        ? `child ${owner.agent_id}, which has not stopped (it frees itself ${RUNNING_CLAIM_TTL_MS / 60_000} minutes after its last tool call)`
+        : `a spawn allowed ${seconds} s ago that has not started yet (if Codex rejected that spawn, the surface frees itself ${PENDING_CLAIM_TTL_MS / 1000} s after it)`;
+    return `SKS exclusive GUI surface gate denied spawn_agent (agent_type "${agentType}"): the ${label} surface is already owned by ${who}. ${label} drives one shared screen or session with one pointer and keyboard focus, so only one child may operate it at a time and a second operator would only repeat the same task. Wait for that child to finish and use its returned evidence, or fold this task into that single operator slice; spawn another ${label} child only after it stops. Do not give the same task to another child and do not do it in the parent while that child runs.`;
+}
+export async function claimExclusiveGuiSurface(input) {
+    if (!isSpawnAgentToolName(spawnPayloadToolName(input.payload)))
+        return ALLOW;
+    const spawn = spawnToolInput(input.payload);
+    const agentType = text(spawn.agent_type ?? spawn.agentType);
+    const surface = exclusiveSurfaceOfRole(agentType);
+    if (!surface)
+        return ALLOW;
+    const toolUseId = text(input.payload?.tool_use_id ?? input.payload?.toolUseId) || null;
+    try {
+        return await withClaims(input, (claims, at) => {
+            const owner = claims.find((claim) => claim.surface === surface);
+            if (owner?.state === 'pending' && toolUseId && owner.tool_use_id === toolUseId)
+                return { claims, result: ALLOW };
+            if (owner)
+                return { claims, result: { action: 'block', message: denyMessage(surface, agentType, owner, at) } };
+            const iso = new Date(at).toISOString();
+            const pending = { surface, state: 'pending', agent_type: agentType, agent_id: null, tool_use_id: toolUseId, claimed_at: iso, last_seen_at: iso };
+            return { claims: [...claims, pending], result: ALLOW };
+        });
+    }
+    catch {
+        return ALLOW;
+    }
+}
+export async function bindExclusiveGuiSurfaceStart(input) {
+    const agentId = text(input.payload?.agent_id ?? input.payload?.agentId);
+    const agentType = text(input.payload?.agent_type ?? input.payload?.agentType);
+    const surface = exclusiveSurfaceOfRole(agentType);
+    if (!agentId || !surface)
+        return;
+    await withClaims(input, (claims, at) => {
+        const iso = new Date(at).toISOString();
+        const rest = claims.filter((claim) => claim.agent_id !== agentId || claim.surface === surface);
+        const target = rest.find((claim) => claim.agent_id === agentId)
+            ?? rest
+                .filter((claim) => claim.state === 'pending' && claim.surface === surface)
+                .sort((left, right) => Date.parse(left.claimed_at) - Date.parse(right.claimed_at))[0];
+        if (target) {
+            target.state = 'running';
+            target.agent_id = agentId;
+            target.last_seen_at = iso;
+            return { claims: rest, result: undefined };
+        }
+        rest.push({ surface, state: 'running', agent_type: agentType, agent_id: agentId, claimed_at: iso, last_seen_at: iso });
+        return { claims: rest, result: undefined };
+    });
+}
+export async function releaseExclusiveGuiSurface(input) {
+    const agentId = text(input.payload?.agent_id ?? input.payload?.agentId);
+    if (!agentId)
+        return;
+    const { file } = ledgerPaths(input.root, input.sessionKey);
+    if (!(await readClaims(file)).some((claim) => claim.agent_id === agentId))
+        return;
+    await withClaims(input, (claims) => ({
+        claims: claims.filter((claim) => claim.agent_id !== agentId),
+        result: undefined
+    }));
+}
+export async function refreshExclusiveGuiSurfaceOwner(input) {
+    const agentId = text(input.payload?.agent_id ?? input.payload?.agentId);
+    if (!agentId)
+        return;
+    const agentType = text(input.payload?.agent_type ?? input.payload?.agentType);
+    const surface = exclusiveSurfaceOfRole(agentType);
+    const { file } = ledgerPaths(input.root, input.sessionKey);
+    const at = input.now ?? Date.now();
+    const claims = await readClaims(file);
+    const mine = claims.find((claim) => claim.agent_id === agentId);
+    if (mine) {
+        if (at - Date.parse(mine.last_seen_at) < CLAIM_REFRESH_INTERVAL_MS)
+            return;
+    }
+    else if (!surface || claims.some((claim) => claim.surface === surface && isLive(claim, at))) {
+        return;
+    }
+    await withClaims(input, (live, now) => {
+        const iso = new Date(now).toISOString();
+        const claim = live.find((row) => row.agent_id === agentId);
+        if (claim)
+            claim.last_seen_at = iso;
+        else if (surface && !live.some((row) => row.surface === surface)) {
+            live.push({ surface, state: 'running', agent_type: agentType, agent_id: agentId, claimed_at: iso, last_seen_at: iso });
+        }
+        return { claims: live, result: undefined };
+    });
+}

package/dist/core/hooks-runtime/global-role-pin-refresh.js

@@ -0,0 +1,25 @@
+import path from 'node:path';
+import { globalSksRoot, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+import { tierModelsFingerprint } from '../subagents/model-tiers.js';
+import { refreshStaleManagedRolePins } from '../subagents/role-model-pins.js';
+export const GLOBAL_ROLE_PINS_STAMP_SCHEMA = 'sks.global-role-pins-stamp.v1';
+export function globalRolePinsStampPath() {
+    return path.join(globalSksRoot(), 'state', 'global-role-pins.json');
+}
+export async function maybeRefreshGlobalRolePins() {
+    const tierModels = tierModelsFingerprint();
+    if (tierModels === null)
+        return null;
+    const stampPath = globalRolePinsStampPath();
+    const stamp = await readJson(stampPath, null).catch(() => null);
+    if (stamp?.schema === GLOBAL_ROLE_PINS_STAMP_SCHEMA && stamp?.tier_models === tierModels)
+        return null;
+    const result = await refreshStaleManagedRolePins({ globalOnly: true });
+    await writeJsonAtomic(stampPath, {
+        schema: GLOBAL_ROLE_PINS_STAMP_SCHEMA,
+        tier_models: tierModels,
+        role_pins: result,
+        checked_at: nowIso()
+    });
+    return result;
+}

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

@@ -9,6 +9,7 @@ import { resolveManagedSkillSourcesForAdmission } from './managed-skill-admissio
 import { managedSkillDigestBlocksEnforced } from '../verification-profile.js';
 import { looksLikeActiveContinuationPrompt } from './naruto-decision-gate.js';
 import { effectiveChildModelAllowlist } from '../subagents/child-model-allowlist.js';
+import { EXCLUSIVE_SURFACE_SPAWN_LINE } from '../subagents/exclusive-surface-rule.js';
 import { renderChildModelCriteria, SUBAGENT_MODELS_SETTINGS_HINT } from './subagent-spawn-policy.js';
 import { extractUserPrompt, looksLikeCodexGitAction, looksLikeCodexUiSettingsEvent } from './payload-signals.js';
 const STANDALONE_PARENT_BASE_SKILLS = [
@@ -20,7 +21,8 @@ const STANDALONE_PARENT_BASE_SKILLS = [
 const OFFICIAL_SUBAGENT_SPAWN_CONTRACT_HEAD = [
     'SKS official-subagent spawn contract:',
     '- 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`.'
+    '- 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`.',
+    `- ${EXCLUSIVE_SURFACE_SPAWN_LINE}`
 ];
 const OFFICIAL_SUBAGENT_SPAWN_COMPATIBILITY_CONTEXT = [
     ...OFFICIAL_SUBAGENT_SPAWN_CONTRACT_HEAD,

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

@@ -7,10 +7,9 @@ import { effortForTier, latestModelForTier, latestTierModelSet } from '../subage
 import { readRoleModelPreferences } from '../subagents/role-model-preferences.js';
 import { READ_ONLY_LIST_ROLE } from '../subagents/read-only-list-role.js';
 import { boundedForkTurns, fullHistoryForkContext, renderChildModelList, SUBAGENT_MODELS_SETTINGS_HINT } from './subagent-spawn-policy.js';
-const SPAWN_TOOLS = new Set(['spawn_agent', 'collaboration.spawn_agent', 'functions.spawn_agent']);
+import { isSpawnAgentToolName, spawnPayloadToolName } from './spawn-tool-name.js';
 function spawnInput(payload) {
-    const name = String(payload?.tool_name || payload?.toolName || payload?.tool?.name || '');
-    if (!SPAWN_TOOLS.has(name))
+    if (!isSpawnAgentToolName(spawnPayloadToolName(payload)))
         return null;
     const input = payload?.tool_input || payload?.toolInput || payload?.tool?.input;
     if (!input || typeof input !== 'object' || Array.isArray(input))
@@ -54,9 +53,6 @@ export async function jevSpawnRouting(root, state, payload) {
         return openRouterOnlySpawnRouting(root, state, input, allowlist);
     return { input: await tierSpawnRewrite(root, state, input), route: null };
 }
-export async function jevSpawnModelRewrite(root, state, payload) {
-    return (await jevSpawnRouting(root, state, payload)).input;
-}
 function listState(allowlist) {
     return { schema: OPENROUTER_ONLY_SCHEMA, enabled: true, subagent_models: allowlist.entries, restore: null, updated_at: null };
 }

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

@@ -3,21 +3,37 @@ 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';
+import { tierModelsFingerprint } from '../subagents/model-tiers.js';
+import { refreshStaleManagedRolePins } from '../subagents/role-model-pins.js';
+import { maybeRefreshGlobalRolePins } from './global-role-pin-refresh.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) {
+    await maybeRefreshGlobalRolePins().catch(() => null);
     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)
+    const tierModels = tierModelsFingerprint();
+    if (stamp?.schema === MANAGED_GUIDANCE_STAMP_SCHEMA && stamp?.version === PACKAGE_VERSION
+        && (tierModels === null || stamp?.tier_models === tierModels))
         return null;
     if (!(await isSksProject(projectRoot)))
         return null;
     const report = await reconcileManagedProjectPromptGuidance(projectRoot);
     const migration = await queueProjectMigration(projectRoot).catch(() => null);
-    if (report.errors > 0)
+    let rolePins = null;
+    let rolePinsFailed = false;
+    if (tierModels !== null) {
+        try {
+            rolePins = await refreshStaleManagedRolePins({ root: projectRoot });
+        }
+        catch {
+            rolePinsFailed = true;
+        }
+    }
+    if (report.errors > 0 || rolePinsFailed)
         return { refreshed: report.refreshed, migration };
     await ensureConfinedDirectory(projectRoot, path.dirname(stampPath));
     await writeJsonAtomic(stampPath, {
@@ -25,6 +41,8 @@ export async function maybeReconcileManagedGuidancePreflight(root) {
         version: PACKAGE_VERSION,
         refreshed: report.refreshed,
         migration,
+        tier_models: tierModels,
+        role_pins: rolePins,
         checked_at: nowIso()
     });
     return { refreshed: report.refreshed, migration };

package/dist/core/hooks-runtime/parent-orchestration-gate.js

@@ -5,11 +5,11 @@ import { nowIso, readJson, sha256, writeJsonAtomic } from '../fsx.js';
 import { ensureConfinedDirectory } from '../managed-path-safety.js';
 import { missionDir } from '../mission.js';
 import { readSubagentEvents } from '../subagents/subagent-evidence.js';
+import { isSpawnAgentToolName } from './spawn-tool-name.js';
 export const PARENT_ORCHESTRATION_GATE_FILENAME = 'parent-orchestration-gate.json';
 export const PARENT_ORCHESTRATION_GATE_SCHEMA = 'sks.parent-orchestration-gate.v1';
 export const PARENT_ORCHESTRATION_MAX_BLOCKS = 2;
 const MAX_TARGETS = 16;
-const SPAWN_TOOL_RE = /^(?:functions\.|collaboration\.)?spawn_agent$/;
 const FILE_EDIT_TOOL_RE = /^(?:functions\.)?(?:apply_patch|edit|write|multiedit|notebookedit|str_replace_editor|str_replace_based_edit_tool|file_write|fs_write|write_file|create_file|edit_file|update_file|delete_file)$/i;
 const SHELL_TOOL_RE = /^(?:functions\.)?(?:shell|shell_command|exec_command|local_shell|bash|container\.exec)$/i;
 const SHELL_WRITE_RE = new RegExp([
@@ -37,7 +37,7 @@ function spawnRouteOf(raw) {
     return route.mode && route.model && route.source ? route : null;
 }
 export function isSpawnToolPayload(payload = {}) {
-    return SPAWN_TOOL_RE.test(toolNameOf(payload));
+    return isSpawnAgentToolName(toolNameOf(payload));
 }
 function toolNameOf(payload = {}) {
     return String(payload?.tool_name || payload?.toolName || payload?.tool?.name || payload?.name || '').trim();
@@ -138,7 +138,7 @@ function collectShellTargets(command, targets) {
 }
 export function parentMutationIntent(payload = {}) {
     const toolName = toolNameOf(payload);
-    if (!toolName || SPAWN_TOOL_RE.test(toolName))
+    if (!toolName || isSpawnAgentToolName(toolName))
         return null;
     const input = toolInputOf(payload);
     const command = commandText(input, payload);

package/dist/core/hooks-runtime/payload-signals.js

@@ -155,7 +155,7 @@ export function observedParentModelMismatch(model, expectedModel) {
     const value = String(model || '').trim();
     if (!value)
         return false;
-    return value.toLowerCase() !== expectedModel && !/gpt[-_. ]?5\.6[-_. ]?sol|\bsol(?:\s+max)?\b/i.test(value);
+    return value.toLowerCase() !== String(expectedModel || '').trim().toLowerCase();
 }
 export function looksLikeCodexUiSettingsEvent(payload = {}) {
     const prompt = stripVisibleDecisionAnswerBlocks(extractUserPrompt(payload));

package/dist/core/hooks-runtime/spawn-role-pin-heal.js

@@ -0,0 +1,15 @@
+import { effectiveChildModelAllowlist } from '../subagents/child-model-allowlist.js';
+import { refreshStaleManagedRolePins, stalePinForAgentType } from '../subagents/role-model-pins.js';
+import { isSpawnAgentToolName, spawnPayloadToolName } from './spawn-tool-name.js';
+export async function healStaleRolePinForSpawn(payload, root) {
+    if (!isSpawnAgentToolName(spawnPayloadToolName(payload)))
+        return false;
+    const input = payload?.tool_input || payload?.toolInput || payload?.tool?.input || {};
+    const agent = String(input.agent_type || input.agentType || '').trim();
+    if (!agent || !stalePinForAgentType(agent, { root }))
+        return false;
+    if (effectiveChildModelAllowlist().mode === 'openrouter_only')
+        return false;
+    await refreshStaleManagedRolePins({ root });
+    return true;
+}

package/dist/core/hooks-runtime/spawn-tool-name.js

@@ -0,0 +1,7 @@
+const SPAWN_AGENT_TOOL_RE = /^(?:functions\.)?(?:(?:collaboration|multi_agent_v\d+)[._]?)?spawn_agent$/;
+export function isSpawnAgentToolName(name) {
+    return SPAWN_AGENT_TOOL_RE.test(String(name ?? '').trim());
+}
+export function spawnPayloadToolName(payload = {}) {
+    return String(payload?.tool_name || payload?.toolName || payload?.tool?.name || '');
+}

package/dist/core/hooks-runtime/subagent-spawn-policy.js

@@ -1,7 +1,8 @@
 import { managedOfficialSubagentRoleByName } from '../managed-assets/managed-assets-manifest.js';
 import { READ_ONLY_LIST_ROLE } from '../subagents/read-only-list-role.js';
+import { stalePinBlockReason, stalePinForAgentType } from '../subagents/role-model-pins.js';
+import { isSpawnAgentToolName, spawnPayloadToolName } from './spawn-tool-name.js';
 import { effectiveChildModelAllowlist, isAllowedChildModel } from '../subagents/child-model-allowlist.js';
-const SPAWN_TOOLS = new Set(['spawn_agent', 'collaboration.spawn_agent', 'functions.spawn_agent']);
 export const SUBAGENT_MODELS_SETTINGS_HINT = 'SKS Control Center > Subagent Models';
 export function renderChildModelList(allowlist) {
     if (allowlist.mode !== 'openrouter_only')
@@ -31,9 +32,8 @@ export function boundedForkTurns(value) {
     return value === 'none' || /^[1-9]\d*$/.test(String(value || ''));
 }
 const FORK_BLOCK_REASON = 'SKS child spawns require fork_turns="none" or a positive bounded turn count. Retry with the complete slice contract in message; full-history/default forks cannot carry an explicit child model.';
-export function subagentSpawnPolicyBlockReason(payload = {}) {
-    const name = String(payload.tool_name || payload.toolName || payload.tool?.name || '');
-    if (!SPAWN_TOOLS.has(name))
+export function subagentSpawnPolicyBlockReason(payload = {}, opts = {}) {
+    if (!isSpawnAgentToolName(spawnPayloadToolName(payload)))
         return null;
     const input = payload.tool_input || payload.toolInput || payload.tool?.input || {};
     const allowlist = effectiveChildModelAllowlist();
@@ -52,6 +52,9 @@ export function subagentSpawnPolicyBlockReason(payload = {}) {
         if (!allowed.has(String(input.model || ''))) {
             return `SKS children must name a current model: ${[...allowed].join(', ')} (the latest fast, balanced, context, or deep tier). Retry spawn_agent with the slice contract model, which the SKS hook re-seals when Jev mode is on, and fork_turns="none" or a positive bounded turn count. Include the complete slice contract in message; do not inherit the parent model.`;
         }
+        const stale = opts.root ? stalePinForAgentType(String(input.agent_type || input.agentType || ''), { root: opts.root }) : null;
+        if (stale)
+            return stalePinBlockReason(stale);
     }
     if (!boundedForkTurns(input.fork_turns))
         return FORK_BLOCK_REASON;

package/dist/core/hooks-runtime/subagent-stop-hook.js

@@ -1,6 +1,8 @@
+import { releaseExclusiveGuiSurface } from './exclusive-gui-surface-gate.js';
 import { officialSubagentArtifactDir, recordAndRefreshSubagentEvidence, recordOfficialSubagentLifecycleCaptureFailure } from './official-subagent-lifecycle.js';
 import { clearSubagentSkillAvailabilityGuards } from './subagent-skill-availability.js';
 export async function handleSubagentStop(root, state, payload = {}, sessionKey = null) {
+    await releaseExclusiveGuiSurface({ root, sessionKey, payload }).catch(() => null);
     const artifactDir = officialSubagentArtifactDir(root, state, sessionKey);
     let lifecycleFailure = null;
     let capturedEvent = null;

package/dist/core/hooks-runtime.js

@@ -36,6 +36,9 @@ import { effectiveChildModelAllowlist } from './subagents/child-model-allowlist.
 import { maybeReconcileManagedGuidancePreflight } from './hooks-runtime/managed-guidance-preflight.js';
 import { evaluateParentOrchestrationGate, isSpawnToolPayload, recordParentOrchestrationSpawn } from './hooks-runtime/parent-orchestration-gate.js';
 import { subagentSpawnPolicyBlockReason } from './hooks-runtime/subagent-spawn-policy.js';
+import { healStaleRolePinForSpawn } from './hooks-runtime/spawn-role-pin-heal.js';
+import { bindExclusiveGuiSurfaceStart, claimExclusiveGuiSurface, refreshExclusiveGuiSurfaceOwner } from './hooks-runtime/exclusive-gui-surface-gate.js';
+import { EXCLUSIVE_SURFACE_CHILD_RULE } from './subagents/exclusive-surface-rule.js';
 import { withFileLock } from './locks/file-lock.js';
 import { ensureConfinedDirectory, inspectConfinedPath, removeManagedPathVerified } from './managed-path-safety.js';
 import { buildBoundWaveParentGuidance, renderWaveParentGuidance } from './subagents/wave-parent-guidance.js';
@@ -156,6 +159,7 @@ async function evaluateHookPayloadWithPlan(name, payload, opts, jevPlan) {
     return withNarutoDecision({ continue: true });
 }
 async function hookSubagentStart(root, state, payload = {}, sessionKey = null) {
+    await bindExclusiveGuiSurfaceStart({ root, sessionKey, payload }).catch(() => null);
     const artifactDir = officialSubagentArtifactDir(root, state, sessionKey);
     const sessionArtifactDir = officialSubagentArtifactDir(root, {}, sessionKey);
     const skillGuardBinding = officialSubagentSkillGuardBinding(state);
@@ -184,6 +188,7 @@ async function hookSubagentStart(root, state, payload = {}, sessionKey = null) {
         'Keep the model and reasoning effort your spawn call sealed; do not retarget them.',
         'Use max_depth=1. Naruto children must not spawn children.',
         'Do not duplicate an already assigned slice.',
+        EXCLUSIVE_SURFACE_CHILD_RULE,
         'Parallel writes require disjoint paths; serialize overlapping paths.',
         'Finish only your assigned slice, return a concise result, then stop so the Naruto parent can close this thread.'
     ].join(' ') : '';
@@ -648,12 +653,14 @@ async function consumeActiveOfficialWorkflowQueue(root, missionId, workflowRunId
     }
 }
 async function hookPreTool(root, state, payload, noQuestion, sessionKey = null) {
+    await refreshExclusiveGuiSurfaceOwner({ root, sessionKey, payload }).catch(() => null);
+    await healStaleRolePinForSpawn(payload, root).catch(() => false);
     const jevSpawn = await jevSpawnRouting(root, state, payload).catch(() => null);
     const jevSpawnInput = jevSpawn?.input ?? null;
     const spawnPayload = jevSpawnInput
         ? { ...payload, tool_input: jevSpawnInput, toolInput: jevSpawnInput }
         : payload;
-    const spawnPolicyBlock = subagentSpawnPolicyBlockReason(spawnPayload);
+    const spawnPolicyBlock = subagentSpawnPolicyBlockReason(spawnPayload, { root });
     if (spawnPolicyBlock)
         return { decision: 'block', permissionDecision: 'deny', reason: spawnPolicyBlock };
     const artifactDir = officialSubagentArtifactDir(root, state, sessionKey);
@@ -725,6 +732,10 @@ async function hookPreTool(root, state, payload, noQuestion, sessionKey = null)
     if (hostCapabilityDecision && hostCapabilityDecision.continue !== true)
         return hostCapabilityDecision;
     if (isSpawnToolPayload(spawnPayload)) {
+        const guiSurface = await claimExclusiveGuiSurface({ root, sessionKey, payload: spawnPayload }).catch(() => null);
+        if (guiSurface?.action === 'block') {
+            return { decision: 'block', permissionDecision: 'deny', reason: guiSurface.message };
+        }
         await recordParentOrchestrationSpawn(root, state, jevSpawn?.route ? { spawnRoute: jevSpawn.route } : {}).catch(() => null);
     }
     const waveGuidance = await parentWaveGuidanceContext(root, state, sessionKey).catch(() => '');

package/dist/core/init.js

@@ -214,6 +214,7 @@ const AGENTS_BLOCK = [
     '- Codex native `/goal` is the only persisted goal owner. Goal objectives must state the outcome, scope, constraints, verification, done-when conditions, stop conditions, and non-goals.',
     '- Answer, Help, Goal, and tiny DFix stay parent-owned. Implementation routes to Naruto (`$sks-naruto`, alias `$sks-work`; standalone `sks naruto run`), which is parent orchestration only: decompose, assign disjoint slices, spawn, integrate, and verify. Do not implement those slices in the parent thread. The SKS PreToolUse hook denies parent-thread source edits until the first child thread starts and while children are still running; .sneakoscope artifacts stay parent-writable, and Jev may release a confirmed orchestration-scaffolding edit.',
     '- The parent owns decomposition, integration, verification, and the final answer. Delegate implementation slices with disjoint write scopes, reuse capacity across root-owned waves, and never nest subagents.',
+    '- Computer Use and browser are exclusive GUI surfaces: one child per surface at a time, with all of that surface\'s work in one slice. Never fan the same GUI task out to several children.',
     '- Every child runs the newest model of the tier its work needs (fast, balanced, context, or deep); no model family is pinned. When Jev mode is on, Jev picks the tier for each new Naruto child spawn and SKS seals it. A user role preference stays authoritative. Do not pick a child model yourself.',
     '- Preserve the user-selected parent model, reasoning effort, and service tier. Parent settings stay on the parent thread. A role preference wins over the Jev seal for that role.',
     '- SKS child spawns must pass the sealed model and reasoning effort with `fork_turns="none"` or a positive bounded turn count; carry the complete bounded slice contract in `message`. Never use full-history inheritance for children. Full-history forks (`fork_turns="all"`, including the omitted default) inherit the parent agent type, model, and reasoning effort and must not be combined with `agent_type`, `model`, or `reasoning_effort`.',

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

@@ -590,7 +590,7 @@ function officialSubagentRole(input) {
         codex_name: input.codexName,
         description: input.description,
         model_policy: profile.policy,
-        model: profile.model,
+        get model() { return subagentModelProfile(input.policy).model; },
         model_reasoning_effort: profile.modelReasoningEffort,
         ...(input.sandbox ? { sandbox: input.sandbox } : {}),
         nickname_candidates: input.nicknames,

package/dist/core/pipeline-internals/runtime-core.js

@@ -27,7 +27,6 @@ import { coreEngineeringDirectiveReferenceText, engineeringSanityPolicyText } fr
 import { classifyTaskProfile, gateProfileForTask } from '../runtime/task-profile.js';
 import { chooseVerificationBudget } from '../runtime/verification-budget.js';
 import { stopFinalizationRitualsEnforced } from '../verification-profile.js';
-import { NARUTO_PARENT_MODEL } from '../subagents/model-policy.js';
 import { HARD_NARUTO_MAX_THREADS } from '../subagents/thread-budget.js';
 import { NARUTO_GATE_FILENAME, NARUTO_SUMMARY_FILENAME, SUBAGENT_PLAN_FILENAME, prepareOfficialSubagentMission } from '../subagents/official-subagent-preparation.js';
 import { buildSubagentEvidence, readSubagentEvents, recordSubagentEvent, SUBAGENT_EVIDENCE_FILENAME, SUBAGENT_EVENT_LOG_FILENAME, SUBAGENT_PARENT_SUMMARY_FILENAME } from '../subagents/subagent-evidence.js';
@@ -1320,7 +1319,7 @@ async function prepareNaruto(root, route, task, required, opts = {}) {
             prompt: cleanTask
         })
     });
-    const { budget, delegationPrompt, workflowRunId, taskProfile, officialConfig, triwikiAttention, parentModelMatch } = preparation;
+    const { budget, delegationPrompt, workflowRunId, taskProfile, officialConfig, triwikiAttention, parentModelMatch, plan } = preparation;
     const routeContextPayload = {
         route: 'Naruto',
         command: '$Naruto',
@@ -1337,7 +1336,7 @@ async function prepareNaruto(root, route, task, required, opts = {}) {
         requested_subagents_explicit: requestedSubagents !== undefined,
         max_threads: budget.maxThreads,
         max_depth: budget.maxDepth,
-        parent_model_policy: NARUTO_PARENT_MODEL,
+        parent_model_policy: plan.parent_model_policy,
         observed_parent_model: observedParentModel,
         parent_model_match: parentModelMatch,
         config_sources: officialConfig.sources,

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

@@ -17,7 +17,7 @@ export function narutoModels() {
 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) {
-        return routeNarutoGpt56Model({
+        return routeNarutoTierModel({
             category,
             ...(opts.taskText !== undefined ? { taskText: opts.taskText } : {}),
             ...(opts.riskText !== undefined ? { riskText: opts.riskText } : {}),
@@ -33,10 +33,10 @@ export async function routeModel(category, opts = {}) {
     const reasoning = opts.lbHealth?.quota_low && policy.reasoning === 'xhigh' ? 'high' : policy.reasoning;
     return { model, reasoning, serviceTier: policy.serviceTier };
 }
-export function routeNarutoGpt56Model(input = {}) {
+export function routeNarutoTierModel(input = {}) {
     const category = input.category || 'agentic';
     const explicitRequested = String(input.explicitModel || '').trim();
-    const explicit = normalizeNarutoGpt56Model(input.explicitModel);
+    const explicit = normalizeNarutoTierModel(input.explicitModel);
     const invalidExplicit = Boolean(explicitRequested && !explicit);
     const explicitHighRisk = /critical|forensic|security|database|migration|release|production|high[- ]?risk|data\s*loss|permission|auth|보안|데이터베이스|마이그레이션|릴리스|운영|고위험/i.test(String(input.riskText || ''));
     const automatic = decideSubagentModel({
@@ -53,7 +53,7 @@ export function routeNarutoGpt56Model(input = {}) {
     const preferred = explicit || automatic.model;
     const available = input.availableModels == null
         ? narutoModels()
-        : input.availableModels.map(normalizeNarutoGpt56Model).filter((model) => Boolean(model));
+        : input.availableModels.map(normalizeNarutoTierModel).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);
@@ -63,16 +63,13 @@ export function routeNarutoGpt56Model(input = {}) {
     const model = !invalidExplicit && usable.includes(preferred) && (availableEfforts == null || availableEfforts.includes(intendedReasoning)) ? preferred : '';
     return { model, reasoning: intendedReasoning, serviceTier: 'fast' };
 }
-export function isNarutoGpt56Model(value) {
-    return normalizeNarutoGpt56Model(value) !== null;
+export function isNarutoTierModel(value) {
+    return normalizeNarutoTierModel(value) !== null;
 }
-export function normalizeNarutoGpt56Model(value) {
+export function normalizeNarutoTierModel(value) {
     const model = String(value || '').trim().toLowerCase();
     return narutoModels().includes(model) ? model : null;
 }
-export function childInheritsActiveMainModel(_value) {
-    return false;
-}
 export function categoryForWorkerRole(role, taskText = '') {
     const text = `${String(role || '')} ${String(taskText || '')}`.toLowerCase();
     if (/(refactor|re-?architect|리팩터|아키텍처)/i.test(text))
@@ -95,7 +92,7 @@ export function modelRouteReason(category, choice, opts = {}) {
         return `${category}->blocked (explicit model unavailable)`;
     if (opts.explicit)
         return `${category}->${model} (explicit model preserved)`;
-    if (isNarutoGpt56Model(choice.model))
+    if (isNarutoTierModel(choice.model))
         return `${category}->${model}@${choice.reasoning} (official subagent model policy)`;
     const suffix = opts.quotaLow ? 'quota discipline' : 'Codex catalog passthrough';
     return `${category}->${model} (${suffix})`;

package/dist/core/recallpulse/policy.js

@@ -1,4 +1,4 @@
-import { thinkingSubagentModel, SUBAGENT_EFFORT } from '../subagents/model-policy.js';
+import { judgmentSubagentModel, DEEP_SUBAGENT_EFFORT } from '../subagents/model-policy.js';
 export const RECALLPULSE_DECISION_ARTIFACT = 'recallpulse-decision.json';
 export const RECALLPULSE_HISTORY_ARTIFACT = 'recallpulse-history.jsonl';
 export const MISSION_STATUS_LEDGER_ARTIFACT = 'mission-status-ledger.json';
@@ -201,7 +201,7 @@ export const RESEARCH_REVIEWER_CONTRACT = Object.freeze([
     ...agent,
     persona_boundary: 'Apply only the assigned review dimension and report evidence-bound findings.',
     custom_agent: 'research_reviewer',
-    model: thinkingSubagentModel(),
-    reasoning_effort: SUBAGENT_EFFORT,
+    model: judgmentSubagentModel(),
+    reasoning_effort: DEEP_SUBAGENT_EFFORT,
     service_tier: 'fast'
 })));

package/dist/core/recallpulse.js

@@ -199,7 +199,7 @@ export async function evaluateRecallPulseFixtures(root, opts = {}) {
             fixture('repeated-stop-hook-blocker', true, 'Duplicate suppression keys collapse repeated blocker text into one durable status row.'),
             fixture('hook-only-status-visibility', true, 'mission-status-ledger.json preserves recoverable user-visible status.'),
             fixture('research-persona-missing', true, 'Research validation blocks missing agent display_name/persona/persona_boundary.'),
-            fixture('research-model-policy-not-sol-max', true, 'Research validation blocks reviewer rows that are not bound to the research_reviewer latest deep-tier max policy.'),
+            fixture('research-model-policy-not-deep-max', true, 'Research validation blocks reviewer rows that are not bound to the research_reviewer latest deep-tier max policy.'),
             fixture('research-review-evidence-missing', true, 'Research validation blocks reviewer outcomes without source evidence, falsifiers, or probes.'),
             fixture('research-impersonation', true, 'Research validation blocks persona-boundary violations.'),
             fixture('oversized-l1', true, 'L1 token and item limits reject oversized active recall.'),

package/dist/core/research/mock-result.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { thinkingSubagentModel, SUBAGENT_EFFORT } from '../subagents/model-policy.js';
+import { judgmentSubagentModel, DEEP_SUBAGENT_EFFORT } from '../subagents/model-policy.js';
 import { nowIso, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
 import { buildClaimEvidenceMatrixFromLedgers, writeClaimEvidenceMatrix } from './claim-evidence-matrix.js';
 import { DEFAULT_RESEARCH_QUALITY_CONTRACT, writeResearchQualityContract } from './research-quality-contract.js';
@@ -174,8 +174,8 @@ export async function writeMockResearchResult(dir, plan) {
             mandate: agent.mandate,
             model_policy: {
                 custom_agent: RESEARCH_REVIEWER_CUSTOM_AGENT,
-                model: thinkingSubagentModel(),
-                reasoning_effort: SUBAGENT_EFFORT,
+                model: judgmentSubagentModel(),
+                reasoning_effort: DEEP_SUBAGENT_EFFORT,
                 enforcement_source: 'mock_fixture'
             },
             query_set: sourceLedger.queries.filter((query) => query.agent_id === agent.id).map((query) => query.query),