sneakoscope 7.1.0 → 7.3.0

package/dist/core/subagents/official-subagent-preparation.js

@@ -13,11 +13,14 @@ import { createSubagentWaveLifecycle } from './wave-lifecycle.js';
 import { decideOfficialSubagentModel } from '../agents/agent-effort-policy.js';
 import { readBoundedTriwikiAttention } from './triwiki-attention.js';
 import { readRoleModelPreferences } from './role-model-preferences.js';
+import { inferProviderFromModel, readConfiguredCodexModelRoutingContext } from '../codex-app/codex-model-catalog.js';
+import { childInheritsActiveMainModel } from '../provider/model-router.js';
 import { SUBAGENT_EVIDENCE_FILENAME, SUBAGENT_EVENT_LOG_FILENAME, SUBAGENT_PARENT_SUMMARY_FILENAME, normalizeSubagentParentSummary, writeSubagentEvidence } from './subagent-evidence.js';
 import { sksPrefixedDollarCommand, unprefixedSksSkillName } from '../routes/dollar-prefix.js';
 import { withFileLock, tryWithFileLock } from '../locks/file-lock.js';
 import { updateCurrentIfMissionAndRun } from '../mission.js';
 import { HOST_CAPABILITY_HOOK_EVIDENCE_FILENAME, HOST_CAPABILITY_HOOK_OBSERVATIONS_FILENAME, HOST_CAPABILITY_HOOK_PENDING_RUNTIME_FILENAME, HOST_CAPABILITY_HOOK_RUNTIME_FILENAME } from '../agent-bridge/host-capability-runtime.js';
+import { uniqueStrings } from '../text/strings.js';
 export const NARUTO_RESULT_SCHEMA = 'sks.naruto-subagent-workflow.v1';
 export const SUBAGENT_PLAN_FILENAME = 'subagent-plan.json';
 export const NARUTO_SUMMARY_FILENAME = 'naruto-summary.json';
@@ -58,6 +61,33 @@ async function prepareOfficialSubagentMissionLocked(input) {
     const officialConfig = await readOfficialSubagentConfig(input.root);
     const triwikiAttention = await readBoundedTriwikiAttention(input.root, triwikiAttentionLimit(taskProfile), goal);
     const roleModelPreferences = await readRoleModelPreferences({ env: input.env || process.env });
+    const roleModelRouting = await readConfiguredCodexModelRoutingContext({ env: input.env || process.env });
+    const roleModelCatalog = roleModelRouting.catalog;
+    const activeMainModel = input.sessionScope && roleModelRouting.selected_provider && roleModelRouting.selected_model
+        ? {
+            provider: roleModelRouting.selected_provider,
+            model: roleModelRouting.selected_model
+        }
+        : null;
+    const roleModelCatalogBlockers = Object.entries(roleModelPreferences.store.roles).flatMap(([name, preference]) => {
+        const routed = preference.provider !== 'openai' || preference.model.includes('/');
+        if (!routed)
+            return [];
+        if (roleModelRouting.selected_provider !== 'sks-router') {
+            return [`role_model_router_not_selected:${name}`];
+        }
+        const catalogEntry = roleModelCatalog.models.find((entry) => entry.model === preference.model);
+        if (!roleModelCatalog.ok || !catalogEntry) {
+            return [`role_model_preference_not_in_active_catalog:${name}:${preference.model}`];
+        }
+        if (!catalogEntry.reasoning_efforts.includes(preference.reasoning_effort)) {
+            return [`role_model_preference_reasoning_not_in_active_catalog:${name}:${preference.model}:${preference.reasoning_effort}`];
+        }
+        if (catalogEntry.multi_agent_version !== 'v2') {
+            return [`role_model_preference_multi_agent_v2_required:${name}:${preference.model}`];
+        }
+        return [];
+    });
     const operatorRequested = input.requestedSubagentsExplicit ?? input.requestedSubagents !== undefined;
     const routeContract = mode === 'generic' && !operatorRequested
         ? routeOwnedSubagentContract(input.route)
@@ -75,6 +105,7 @@ async function prepareOfficialSubagentMissionLocked(input) {
         taskProfile,
         suggestedRoles: suggestedAgents,
         goal,
+        maxThreads: input.maxThreads ?? officialConfig.maxThreads,
         ...(slices.length > 0 ? { independentSliceCount: slices.length } : {})
     });
     const budget = resolveSubagentThreadBudget({
@@ -119,7 +150,8 @@ async function prepareOfficialSubagentMissionLocked(input) {
         capacity: budget.capacity,
         triwikiAttention,
         recommendedAgents: suggestedAgents,
-        roleModelPreferences: roleModelPreferences.store.roles
+        roleModelPreferences: roleModelPreferences.store.roles,
+        activeMainModel
     });
     const selectedAgentPlan = officialSubagentOnDemandRolePlan(suggestedAgents);
     const agentRouting = Object.fromEntries(Object.entries(selectedAgentPlan).map(([name, config]) => {
@@ -135,13 +167,33 @@ async function prepareOfficialSubagentMissionLocked(input) {
             readonly: config.sandbox_mode === 'read-only'
         });
         const preference = roleModelPreferences.store.roles[name];
+        const inheritActiveMain = childInheritsActiveMainModel(activeMainModel?.model);
+        const routedProvider = preference?.provider
+            || (inheritActiveMain ? activeMainModel?.provider : null)
+            || inferProviderFromModel(config.model || decision.model);
+        const routedModel = preference?.model
+            || (inheritActiveMain ? activeMainModel?.model : null)
+            || config.model
+            || decision.model;
+        const routedReasoning = preference?.reasoning_effort
+            || config.model_reasoning_effort
+            || decision.model_reasoning_effort;
         return [name, {
                 ...config,
-                routed_model: preference?.model || decision.model,
-                routed_model_reasoning_effort: preference?.reasoning_effort || decision.model_reasoning_effort,
-                routed_model_policy: preference ? 'user_role_model_preference' : decision.model_selection_reason,
-                routing_dynamic: !preference,
-                role_model_preference_source: preference ? 'user-scoped-owner-only' : 'managed-default'
+                routed_provider: routedProvider,
+                routed_model: routedModel,
+                routed_model_reasoning_effort: routedReasoning,
+                routed_model_policy: preference
+                    ? 'user_role_model_preference'
+                    : inheritActiveMain
+                        ? 'active_main_model'
+                        : (config.model_policy || decision.model_selection_reason),
+                routing_dynamic: !preference && !inheritActiveMain,
+                role_model_preference_source: preference
+                    ? 'user-scoped-owner-only'
+                    : inheritActiveMain
+                        ? 'active-main-model'
+                        : 'managed-default'
             }];
     }));
     const agentCatalog = onDemandAgentCatalogMetadata(selectedAgentPlan);
@@ -150,6 +202,7 @@ async function prepareOfficialSubagentMissionLocked(input) {
     const configBlockers = [
         ...officialConfig.blockers,
         ...roleModelPreferences.blockers,
+        ...roleModelCatalogBlockers,
         ...ssotGuardValidation.issues.map((issue) => `ssot_guard:${issue}`),
         ...sliceSafety.blockers.map((blocker) => `subagent_slice:${blocker}`),
         ...(budget.capacity.exhausted ? ['subagent_capacity_exhausted'] : [])
@@ -201,7 +254,20 @@ async function prepareOfficialSubagentMissionLocked(input) {
             schema: roleModelPreferences.store.schema,
             path: roleModelPreferences.path,
             overrides: roleModelPreferences.store.roles,
-            blockers: roleModelPreferences.blockers
+            routing: {
+                selected_provider: roleModelRouting.selected_provider,
+                selected_model: roleModelRouting.selected_model,
+                active_main_model_inherited: childInheritsActiveMainModel(activeMainModel?.model),
+                runtime_verified: false
+            },
+            catalog: {
+                configured: roleModelCatalog.configured,
+                ok: roleModelCatalog.ok,
+                path: roleModelCatalog.path,
+                model_count: roleModelCatalog.model_count,
+                blockers: roleModelCatalog.blockers
+            },
+            blockers: [...roleModelPreferences.blockers, ...roleModelCatalogBlockers]
         },
         verification_budget: verification,
         verification_checks: [],
@@ -974,6 +1040,3 @@ function isNarutoRecord(value) {
 function narutoErrorCode(error) {
     return error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
 }
-function uniqueStrings(values) {
-    return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))];
-}

package/dist/core/subagents/official-subagent-prompt.js

@@ -1,6 +1,7 @@
 import { HARD_NARUTO_MAX_THREADS } from './thread-budget.js';
 import { coreEngineeringDirectiveReferenceText } from '../lean-engineering-policy.js';
 import { MAX_AUTOMATIC_REVIEWER_COUNT, MAX_AUTOMATIC_SUBAGENT_COUNT, MAX_CRITICAL_AUTOMATIC_REVIEWER_COUNT, officialSubagentOnDemandRoleCatalog, officialSubagentRoleCatalog, selectOfficialSubagentRole } from './agent-catalog.js';
+import { childInheritsActiveMainModel } from '../provider/model-router.js';
 export function buildOfficialSubagentPrompt(input) {
     const maxThreads = clampThreads(input.maxThreads);
     const requestedSubagents = normalizeRequestedSubagents(input.requestedSubagents, input.slices.length);
@@ -41,18 +42,37 @@ export function buildOfficialSubagentPrompt(input) {
         ...resolvedSlices.map((row) => row.agentName),
         ...(input.recommendedAgents || [])
     ]);
+    const activeMainModel = normalizedActiveMainModel(input.activeMainModel);
+    const inheritActiveMainOntoChildren = childInheritsActiveMainModel(activeMainModel?.model);
+    const spawnModelRouting = renderSpawnModelRouting(activeMainModel);
     const rows = resolvedSlices.map(({ slice, agentName }, index) => {
         const mode = slice.readOnly ? 'read-only' : 'use the parent permission mode';
         const paths = (slice.paths || []).map((entry) => String(entry).trim()).filter(Boolean);
         const role = officialSubagentOnDemandRoleCatalog([agentName])[0];
         const preference = input.roleModelPreferences?.[agentName];
+        const sealedReasoning = role?.model_reasoning_effort || 'medium';
+        const sealedModel = role?.model || null;
+        const effectiveModel = preference
+            ? `${preference.provider}:${preference.model}/${preference.reasoning_effort} (user override)`
+            : inheritActiveMainOntoChildren && activeMainModel
+                ? `${activeMainModel.provider}:${activeMainModel.model}/${sealedReasoning} (active main model)`
+                : sealedModel
+                    ? `${inferDisplayProvider(sealedModel)}:${sealedModel}/${sealedReasoning} (sealed role policy)`
+                    : 'managed default/dynamic routing';
+        const spawnContract = preference
+            ? `pass the exact catalog slug model=${JSON.stringify(preference.model)} and reasoning_effort=${JSON.stringify(preference.reasoning_effort)} when spawning this role; logical provider=${JSON.stringify(preference.provider)} is encoded by the active router/catalog and is not a spawn_agent argument`
+            : inheritActiveMainOntoChildren && activeMainModel
+                ? `pass the exact active main model=${JSON.stringify(activeMainModel.model)} and reasoning_effort=${JSON.stringify(sealedReasoning)} when spawning this role; the current app session already owns provider=${JSON.stringify(activeMainModel.provider)}`
+                : sealedModel
+                    ? `pass model=${JSON.stringify(sealedModel)} and reasoning_effort=${JSON.stringify(sealedReasoning)} from the sealed role policy; do not replace Luna/Terra/Sol High/Sol Max with the parent active main model`
+                    : 'omit model/reasoning overrides and preserve the installed custom-agent default';
         return [
             `${index + 1}. [${slice.id}] use custom agent \`${agentName}\``,
             `   title: ${slice.title}`,
             `   task: ${slice.description}`,
             `   model policy: ${role ? `${role.model_policy} (${role.model}/${role.model_reasoning_effort})` : 'resolve from installed custom agent'}`,
-            `   effective model preference: ${preference ? `${preference.model}/${preference.reasoning_effort} (user override)` : 'managed default/dynamic routing'}`,
-            `   spawn contract: ${preference ? `pass model=${JSON.stringify(preference.model)} and reasoning_effort=${JSON.stringify(preference.reasoning_effort)} when spawning this role` : 'omit model/reasoning overrides and preserve the installed custom-agent default'}`,
+            `   effective model preference: ${effectiveModel}`,
+            `   spawn contract: ${spawnContract}`,
             '   context contract: pass fork_turns="none" and carry this complete bounded slice contract in message because agent_type is selected',
             `   mode: ${mode}`,
             `   paths: ${paths.join(', ') || 'assigned by parent'}`
@@ -64,33 +84,34 @@ Use a Codex subagent workflow for the independent slices below.
 ${coreEngineeringDirectiveReferenceText()}
 
 Parent agent:
-- model policy: gpt-5.6-sol with max reasoning
+- model policy: ${activeMainModel ? `keep the current app-selected main model ${activeMainModel.provider}:${activeMainModel.model}` : 'gpt-5.6-sol with max reasoning'}
 - owns decomposition, integration, and final answer
 - do not do duplicate work already delegated
 
 Host capability policy:
-- use a host tool only when it is actually available in the project MCP inventory; do not infer availability from config text or duplicate host tool schemas
-- SQL-generation-only requests: call \`datasource_schema_context\` first, use only reported tables and columns, and may complete without \`datasource_query_readonly\`
-- actual data retrieval: call \`datasource_schema_context\`, generate one bounded parameterized SELECT/CTE, call \`datasource_query_readonly\`, and retain its receipt
-- spreadsheet create: \`spreadsheet_create\` -> \`spreadsheet_inspect\` -> optional one minimal \`spreadsheet_update\` -> \`spreadsheet_inspect\`
-- spreadsheet edit: \`spreadsheet_inspect\` -> one minimal \`spreadsheet_update\` -> \`spreadsheet_inspect\`
-- document delivery: editable source -> render -> artifact receipt
-- when a requested host capability is missing or unhealthy, return blocked proof; do not fabricate a fallback or success evidence
-- Slack delivery belongs to the ACAS runtime and is never a model tool
+- confirm requested tools in the project MCP inventory; if unavailable or unhealthy, return blocked proof and never fabricate a fallback
+- DB: schema first. SQL-only may stop there; retrieval defaults to one bounded query and allows at most four total for separate aggregation or verification. Every query needs a prior schema receipt for the same datasource and matching snapshot
+- spreadsheet: prefer the smallest create/edit mutation; allow at most three updates, inspect after create and every update, and require the final mutation artifact receipt
+- document: write_file/edit_file then html_to_pdf|html_to_screenshot(source_path=...); never raw html
+- Slack delivery is ACAS-runtime-only, never a model tool
 
 Subagent rules:
 - use only Codex official subagent threads; do not launch shell workers, a custom scheduler, a worker pool, or model fanout
 - select the narrowest matching project custom agent by its description; the custom agent name is the spawn type
 - custom \`agent_type\` selection and spawn-time \`model\`/\`reasoning_effort\` overrides must use \`fork_turns="none"\` or a positive bounded turn count, with the complete bounded slice contract in \`message\`
+- \`spawn_agent\` has no per-child provider argument; cross-provider preferences must use exact model slugs advertised by the active Codex backend/catalog (for example a single multi-provider router exposing \`provider/model\`)
 - never combine \`fork_turns="all"\` or the omitted/default full-history mode with \`agent_type\`, \`model\`, or \`reasoning_effort\`; Codex rejects that start before SubagentStart
 - a full-history fork is allowed only when \`agent_type\`, \`model\`, and \`reasoning_effort\` are all omitted
-- use \`worker\` with gpt-5.6-luna and max reasoning only for tiny, short-context, mechanical work with no exploration or judgment
+${spawnModelRouting}
+- use \`worker\` with gpt-5.6-luna and max reasoning for tiny short-context mechanical work such as simple search, typing, rename, copy, label, or one-line edits with no exploration or judgment
 - use gpt-5.6-sol with high reasoning for ordinary UI, logic, backend, and native implementation
 - use gpt-5.6-sol with max reasoning only for focused unresolved, high-risk, final-review, architecture, security, database, research, release, or other explicit judgment slices
-- use gpt-5.6-terra with medium reasoning for read-heavy documentation/exploration, long-context analysis, and direct Computer Use, Browser/Chrome, or image-generation execution
-- explicit task class and phase win over incidental keywords: Terra gathers/explores, Sol High implements, and Sol Max performs the focused judgment pass
-- never assign Luna to long-context, exploration, review, debugging, planning, or tool-heavy work
-- automatic fan-out starts at two for bounded non-trivial work, four for explicit parallel work, and six for large-scale work; it may expand only up to ${MAX_AUTOMATIC_SUBAGENT_COUNT} when decomposition proves more independent useful slices
+- use gpt-5.6-terra with medium reasoning for read-heavy documentation/exploration, long-context analysis, large or repository-wide search, and direct Computer Use, Browser/Chrome, or image-generation execution
+- explicit task class and phase win over incidental keywords: Terra gathers/explores/searches broadly, Luna handles tiny mechanical edits, Sol High implements, and Sol Max performs the focused judgment pass
+- never assign Luna to long-context, broad exploration, review, debugging, planning, or tool-heavy work
+- never collapse every child onto the parent Sol model when a sealed Luna or Terra role matches the slice
+- automatic fan-out starts at four for bounded non-trivial work, six for explicit parallel work, and eight for large-scale work; it may expand only up to ${MAX_AUTOMATIC_SUBAGENT_COUNT} when independent useful slices and healthy host capacity remain positive
+- prefer the largest useful first wave the host can sustain; shrink only under live resource pressure or unsafe overlapping ownership
 - automatic reviewer-only fan-out is capped at ${MAX_AUTOMATIC_REVIEWER_COUNT} for ordinary work and ${MAX_CRITICAL_AUTOMATIC_REVIEWER_COUNT} for critical multi-domain review
 - requested subagents: ${requestedPolicy}
 - max open agent threads: ${maxThreads} (hard cap, never a utilization target)
@@ -128,7 +149,7 @@ Central TriWiki context:
 ${triwiki}
 
 Role model preference metadata:
-${renderRoleModelPreferenceMetadata(input.roleModelPreferences)}
+${renderRoleModelPreferenceMetadata(input.roleModelPreferences, activeMainModel)}
 
 Project custom agent catalog:
 ${catalog}
@@ -181,15 +202,61 @@ Final parent output:
 - keep completion summary and Honest Mode wording inside the JSON fields; do not add prose outside the object
 `.trim();
 }
-function renderRoleModelPreferenceMetadata(preferences) {
+function renderRoleModelPreferenceMetadata(preferences, activeMainModel) {
     const rows = Object.entries(preferences || {}).map(([role, preference]) => ({
         role,
+        provider: preference.provider,
         model: preference.model,
         reasoning_effort: preference.reasoning_effort,
         source: 'user-scoped-owner-only'
     }));
+    if (activeMainModel && childInheritsActiveMainModel(activeMainModel.model)) {
+        rows.push({
+            role: '*',
+            provider: activeMainModel.provider,
+            model: activeMainModel.model,
+            reasoning_effort: 'role-managed',
+            source: 'active-main-model-fallback'
+        });
+    }
     return rows.length ? JSON.stringify(rows) : '[]';
 }
+function normalizedActiveMainModel(value) {
+    const provider = String(value?.provider || '').trim();
+    const model = String(value?.model || '').trim();
+    return provider && model ? { provider, model } : null;
+}
+function inferDisplayProvider(model) {
+    return model.includes('/') ? model.split('/', 1)[0] || 'openai' : 'openai';
+}
+function renderSpawnModelRouting(activeMainModel) {
+    const inheritActiveMain = childInheritsActiveMainModel(activeMainModel?.model);
+    const precedence = inheritActiveMain
+        ? '- model routing precedence applies to every child, including slices created after parent decomposition: exact user role override -> active main model -> installed custom-agent default'
+        : '- model routing precedence applies to every child, including slices created after parent decomposition: exact user role override -> sealed role policy (Luna Max / Terra Medium / Sol High / Sol Max) -> installed custom-agent default';
+    const roleOverride = '- when Role model preference metadata lists the selected role with source "user-scoped-owner-only", pass that row\'s exact model and reasoning_effort to spawn_agent';
+    if (!activeMainModel) {
+        return [
+            precedence,
+            roleOverride,
+            '- when no user override exists, pass the sealed role model/effort from the selected custom agent; do not default every child to Sol'
+        ].join('\n');
+    }
+    if (!inheritActiveMain) {
+        return [
+            precedence,
+            roleOverride,
+            `- parent keeps the app-selected main model ${activeMainModel.provider}:${activeMainModel.model}, but children must keep sealed Luna/Terra/Sol High/Sol Max role profiles`,
+            '- for every role without a user override, including slices created after parent decomposition, pass that role\'s sealed model and reasoning_effort; never replace Luna or Terra with the parent Sol model'
+        ].join('\n');
+    }
+    return [
+        precedence,
+        roleOverride,
+        `- for every role without a user override, including slices created after parent decomposition, pass model=${JSON.stringify(activeMainModel.model)} and the selected custom role's installed reasoning effort; provider=${JSON.stringify(activeMainModel.provider)} remains owned by the current app session`,
+        `- do not substitute a managed GPT model for the active main model ${activeMainModel.provider}:${activeMainModel.model}`
+    ].join('\n');
+}
 export function validateOfficialSubagentSlices(slices) {
     const blockers = [];
     const duplicateSliceIds = [];

package/dist/core/subagents/official-subagent-runner.js

@@ -2,14 +2,17 @@ import fsp from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { randomId, runProcess, writeJsonAtomic } from '../fsx.js';
-import { missionDir } from '../mission.js';
 import { DEFAULT_SUBAGENT_EFFORT, DEFAULT_SUBAGENT_MODEL, NARUTO_PARENT_EFFORT, NARUTO_PARENT_MODEL } from './model-policy.js';
 import { inspectCodexLbCliLaunchRecovery } from '../codex-control/codex-lb-launch-recovery.js';
 import { probeNarutoCodexCapability } from '../codex-compat/codex-capability-matrix.js';
 import { resolveOfficialCodexPackageRuntime } from '../codex-runtime/resolve-codex-runtime.js';
 import { withFileLock } from '../locks/file-lock.js';
 import { HOST_CAPABILITY_HOOK_PENDING_RUNTIME_FILENAME, HOST_CAPABILITY_MCP_SERVER, createHostCapabilityHookPendingRuntime, createHostCapabilityEventCollector, hostCapabilityCodexConfigArgs, inspectHostCapabilityRuntime, requestHostCapabilities } from '../agent-bridge/host-capability-runtime.js';
+import { uniqueStringsSorted as uniqueStrings } from '../text/strings.js';
 export const OFFICIAL_SUBAGENT_WORKFLOW_SCHEMA = 'sks.subagent-workflow.v1';
+function officialSubagentMissionDir(root, missionId) {
+    return path.join(root, '.sneakoscope', 'missions', missionId);
+}
 const OFFICIAL_SUBAGENT_CHILD_ENV_ALLOWLIST = Object.freeze([
     'HOME',
     'USER',
@@ -45,6 +48,11 @@ const OFFICIAL_SUBAGENT_CHILD_ENV_ALLOWLIST = Object.freeze([
     'CODEX_INTERNAL_ORIGINATOR',
     'CODEX_SANDBOX_NETWORK_DISABLED',
     'SKS_AGENT_MODE',
+    'SKS_NARUTO_PARENT_EDGE_ID',
+    'SKS_NARUTO_PARENT_LEASE_OWNER',
+    'SKS_NARUTO_PARENT_LEASE_GENERATION',
+    'SKS_NARUTO_PARENT_MISSION_GENERATION',
+    'ACAS_CUSTOMER_ID',
     'ACAS_AGENT_SLUG',
     'ACAS_AGENT_WORKSPACE',
     'ALFREDO_AGENT_SOULS_FILE',
@@ -333,7 +341,7 @@ export async function runOfficialSubagentWorkflow(input) {
             };
         }
         hostCapabilityLaunchNonce = randomId(32);
-        hostCapabilityPendingDir = missionDir(canonicalRoot, input.missionId);
+        hostCapabilityPendingDir = officialSubagentMissionDir(canonicalRoot, input.missionId);
     }
     const childEnv = buildOfficialSubagentChildEnv({
         ...(input.env ? { env: input.env } : {}),
@@ -589,6 +597,3 @@ function summarizeCodexJsonlOutput(text, secretValues) {
         event_types: uniqueStrings(eventTypes)
     };
 }
-function uniqueStrings(values) {
-    return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))].sort();
-}