sneakoscope 6.2.0 → 6.4.0

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

@@ -1,15 +1,17 @@
 import fsp from 'node:fs/promises';
 import path from 'node:path';
-import { nowIso, randomId, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { nowIso, randomId, readJson, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { SSOT_GUARD_ARTIFACT, buildSsotGuard, validateSsotGuardArtifact } from '../safety/ssot-guard.js';
 import { classifyTaskProfile } from '../runtime/task-profile.js';
 import { chooseVerificationBudget } from '../runtime/verification-budget.js';
-import { buildOfficialSubagentPrompt } from './official-subagent-prompt.js';
+import { buildOfficialSubagentPrompt, validateOfficialSubagentSlices } from './official-subagent-prompt.js';
 import { readOfficialSubagentConfig } from './official-subagent-config.js';
 import { NARUTO_PARENT_EFFORT, NARUTO_PARENT_MODEL } from './model-policy.js';
 import { MAX_ON_DEMAND_SUBAGENT_ROLE_COUNT, officialSubagentFanoutPolicy, officialSubagentOnDemandRolePlan, officialSubagentRoleCatalog, recommendOfficialSubagentRoles } from './agent-catalog.js';
 import { resolveSubagentThreadBudget } from './thread-budget.js';
 import { readBoundedTriwikiAttention } from './triwiki-attention.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';
 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';
@@ -18,11 +20,17 @@ export async function prepareOfficialSubagentMission(input) {
     const goal = String(input.goal || '').trim();
     const mode = input.mode === 'naruto' ? 'naruto' : 'generic';
     const taskProfile = classifyTaskProfile(goal);
-    const suggestedAgents = recommendOfficialSubagentRoles({
-        description: goal,
-        readOnly: input.readOnly === true,
-        requiresWrite: input.readOnly !== true
-    });
+    const slices = Array.isArray(input.slices) ? input.slices : [];
+    const decompositionStatus = slices.length > 0 ? 'ready' : 'parent_required';
+    const sliceSafety = validateOfficialSubagentSlices(slices);
+    const suggestedAgents = uniqueStrings([
+        ...recommendOfficialSubagentRoles({
+            description: goal,
+            readOnly: input.readOnly === true,
+            requiresWrite: input.readOnly !== true
+        }),
+        ...slices.map((slice) => slice.agent || '').filter(Boolean)
+    ]);
     const officialConfig = await readOfficialSubagentConfig(input.root);
     const triwikiAttention = await readBoundedTriwikiAttention(input.root, triwikiAttentionLimit(taskProfile), goal);
     const operatorRequested = input.requestedSubagentsExplicit ?? input.requestedSubagents !== undefined;
@@ -41,18 +49,28 @@ export async function prepareOfficialSubagentMission(input) {
         requestedSource,
         taskProfile,
         suggestedRoles: suggestedAgents,
-        goal
+        goal,
+        ...(slices.length > 0 ? { independentSliceCount: slices.length } : {})
     });
     const budget = resolveSubagentThreadBudget({
         requested: selectedFanoutPolicy.requested_subagents,
-        configuredMaxThreads: input.maxThreads ?? officialConfig.maxThreads
+        configuredMaxThreads: input.maxThreads ?? officialConfig.maxThreads,
+        ...(input.capacity || {}),
+        ...(slices.length > 0
+            ? {
+                independentSliceCount: slices.length,
+                readyDagWidth: input.capacity?.readyDagWidth ?? slices.length,
+                disjointOwnershipCount: input.capacity?.disjointOwnershipCount ?? (sliceSafety.safe ? slices.length : 0)
+            }
+            : {})
     });
     const verification = chooseVerificationBudget({ taskProfile, changedFiles: [] });
     const workflowRunId = String(input.workflowRunId || '').trim()
         || `${mode === 'naruto' ? 'naruto' : 'official'}-${Date.now().toString(36)}-${randomId(8)}`;
     const fanoutPolicy = {
         ...selectedFanoutPolicy,
-        requested_subagents: budget.requestedSubagents
+        requested_subagents: budget.requestedSubagents,
+        capacity_controller: budget.capacity
     };
     const observedParentModel = String(input.observedParentModel || '').trim() || null;
     const parentModelMatch = observedParentModel ? observedParentModelMatchesPolicy(observedParentModel) : null;
@@ -61,18 +79,28 @@ export async function prepareOfficialSubagentMission(input) {
         : goal;
     const delegationPrompt = buildOfficialSubagentPrompt({
         goal: delegationGoal,
-        slices: [],
+        slices,
         requestedSubagents: budget.requestedSubagents,
         requestedSubagentsExplicit: requestedSource === 'operator',
         requestedSubagentsSource: requestedSource,
         maxThreads: budget.maxThreads,
-        decompositionStatus: 'parent_required',
+        decompositionStatus,
+        firstWave: budget.firstWave,
+        waveCount: budget.waveCount,
+        capacity: budget.capacity,
         triwikiAttention,
         recommendedAgents: suggestedAgents
     });
     const selectedAgentPlan = officialSubagentOnDemandRolePlan(suggestedAgents);
     const agentCatalog = onDemandAgentCatalogMetadata(selectedAgentPlan);
-    const configBlockers = officialConfig.blockers.map((blocker) => `official_subagent_config:${blocker}`);
+    const ssotGuard = buildSsotGuard({ route: input.route, mode: mode === 'naruto' ? 'NARUTO' : 'OFFICIAL_SUBAGENT', task: goal });
+    const ssotGuardValidation = validateSsotGuardArtifact(ssotGuard);
+    const configBlockers = [
+        ...officialConfig.blockers,
+        ...ssotGuardValidation.issues.map((issue) => `ssot_guard:${issue}`),
+        ...sliceSafety.blockers.map((blocker) => `subagent_slice:${blocker}`),
+        ...(budget.capacity.exhausted ? ['subagent_capacity_exhausted'] : [])
+    ];
     const plan = {
         schema: 'sks.subagent-plan.v1',
         mission_id: input.missionId,
@@ -83,7 +111,7 @@ export async function prepareOfficialSubagentMission(input) {
         goal,
         read_only: input.readOnly === true,
         task_profile: taskProfile,
-        decomposition_status: 'parent_required',
+        decomposition_status: decompositionStatus,
         delegation_prompt: delegationPrompt,
         requested_subagents: budget.requestedSubagents,
         requested_subagents_explicit: requestedSource === 'operator',
@@ -95,11 +123,13 @@ export async function prepareOfficialSubagentMission(input) {
         max_depth: budget.maxDepth,
         config_source: input.maxThreads === undefined ? officialConfig.sources.maxThreads : 'cli',
         config_sources: officialConfig.sources,
-        config_blockers: officialConfig.blockers,
+        config_blockers: configBlockers,
         triwiki_attention: triwikiAttention,
         suggested_agents: suggestedAgents,
         fanout_policy: fanoutPolicy,
-        slices: [],
+        capacity_controller: budget.capacity,
+        slice_safety: sliceSafety,
+        slices,
         parent_model_policy: NARUTO_PARENT_MODEL,
         observed_parent_model: observedParentModel,
         parent_model_match: parentModelMatch,
@@ -112,7 +142,6 @@ export async function prepareOfficialSubagentMission(input) {
         verification_budget: verification,
         verification_checks: [],
         verification: { budget: verification },
-        legacy_process_swarm_used: false,
         created_at: nowIso()
     };
     const cleanup = [
@@ -124,6 +153,7 @@ export async function prepareOfficialSubagentMission(input) {
     }
     await Promise.all(cleanup);
     await writeTextAtomic(path.join(input.dir, SUBAGENT_EVENT_LOG_FILENAME), '');
+    await writeJsonAtomic(path.join(input.dir, SSOT_GUARD_ARTIFACT), ssotGuard);
     await writeJsonAtomic(path.join(input.dir, SUBAGENT_PLAN_FILENAME), plan);
     const evidence = await writeSubagentEvidence(input.dir, {
         requestedSubagents: budget.requestedSubagents,
@@ -186,7 +216,7 @@ function triwikiAttentionLimit(taskProfile) {
     return ['parallel-read', 'parallel-write', 'high-risk'].includes(taskProfile) ? 6 : 4;
 }
 function routeOwnedSubagentContract(route) {
-    const normalized = String(route || '').replace(/^\$/, '').trim().toLowerCase();
+    const normalized = unprefixedSksSkillName(route);
     if (normalized === 'research') {
         return { count: 3, reason: 'research_exact_three_independent_reviewers' };
     }
@@ -206,7 +236,7 @@ export function buildNarutoSummary(input) {
         ok: input.ok === true,
         completion_evidence: input.ok === true,
         status: input.status,
-        route: '$Naruto',
+        route: sksPrefixedDollarCommand('naruto'),
         workflow: 'official_codex_subagent',
         workflow_run_id: input.workflowRunId || input.evidence?.run_id || null,
         mission_id: input.missionId,
@@ -218,6 +248,9 @@ export function buildNarutoSummary(input) {
         },
         requested_subagents: input.budget.requestedSubagents,
         max_threads: input.budget.maxThreads,
+        first_wave: input.budget.firstWave,
+        wave_count: input.budget.waveCount,
+        capacity_controller: input.budget.capacity,
         max_depth: input.budget.maxDepth,
         started_subagents: Number(input.evidence?.started_threads || 0),
         completed_subagents: Number(input.evidence?.completed_threads || 0),
@@ -234,7 +267,6 @@ export function buildNarutoSummary(input) {
         app_session: input.appSession === true,
         session_scope: input.sessionKey || null,
         blockers: uniqueStrings(input.blockers || input.evidence?.blockers || []),
-        legacy_process_swarm_used: false,
         updated_at: nowIso()
     };
 }
@@ -250,7 +282,20 @@ function onDemandAgentCatalogMetadata(selectedAgentPlan) {
     };
 }
 export async function writeNarutoGate(dir, input) {
-    await writeJsonAtomic(path.join(dir, NARUTO_GATE_FILENAME), buildNarutoGateResult(input));
+    const ssotGuard = await readJson(path.join(dir, SSOT_GUARD_ARTIFACT), null);
+    const ssotValidation = validateSsotGuardArtifact(ssotGuard);
+    const blockers = uniqueStrings([
+        ...(input.blockers || []),
+        ...ssotValidation.issues.map((issue) => `${SSOT_GUARD_ARTIFACT}:${issue}`)
+    ]);
+    const gate = buildNarutoGateResult({
+        ...input,
+        passed: input.passed === true && ssotValidation.ok && blockers.length === 0,
+        ssotGuard: ssotValidation.ok,
+        blockers
+    });
+    await writeJsonAtomic(path.join(dir, NARUTO_GATE_FILENAME), gate);
+    return gate;
 }
 export function buildNarutoGateResult(input) {
     const passed = input.passed === true;
@@ -259,7 +304,7 @@ export function buildNarutoGateResult(input) {
     const failed = Number(input.evidence?.failed_threads || 0);
     return {
         schema: 'sks.naruto-gate.v1',
-        route: '$Naruto',
+        route: sksPrefixedDollarCommand('naruto'),
         workflow: 'official_codex_subagent',
         workflow_run_id: input.workflowRunId || input.evidence?.run_id || null,
         mission_id: input.missionId,
@@ -279,9 +324,18 @@ export function buildNarutoGateResult(input) {
         completed_subagents: Number(input.evidence?.completed_threads || 0),
         failed_subagents: Number(input.evidence?.failed_threads || 0),
         parent_summary_present: input.evidence?.parent_summary_present === true,
+        ssot_guard: input.ssotGuard === true,
         event_sources: input.evidence?.event_sources || [],
+        evidence: {
+            official_subagent_evidence: SUBAGENT_EVIDENCE_FILENAME,
+            parent_summary: SUBAGENT_PARENT_SUMMARY_FILENAME,
+            ssot_guard: SSOT_GUARD_ARTIFACT,
+            requested_subagents: requested,
+            started_threads: Number(input.evidence?.started_threads || 0),
+            completed_threads: completed,
+            failed_threads: failed
+        },
         native_process_proof_required: false,
-        legacy_process_swarm_used: false,
         config_blockers: uniqueStrings(input.configBlockers || []),
         blockers: uniqueStrings(input.blockers || input.evidence?.blockers || []),
         missing_fields: uniqueStrings(input.blockers || input.evidence?.blockers || []),
@@ -294,4 +348,3 @@ function observedParentModelMatchesPolicy(model) {
 function uniqueStrings(values) {
     return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))];
 }
-//# sourceMappingURL=official-subagent-preparation.js.map

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

@@ -1,9 +1,14 @@
 import { HARD_NARUTO_MAX_THREADS } from './thread-budget.js';
-import { MAX_AUTOMATIC_REVIEWER_COUNT, MAX_AUTOMATIC_SUBAGENT_COUNT, officialSubagentOnDemandRoleCatalog, officialSubagentRoleCatalog, selectOfficialSubagentRole } from './agent-catalog.js';
+import { MAX_AUTOMATIC_REVIEWER_COUNT, MAX_AUTOMATIC_SUBAGENT_COUNT, MAX_CRITICAL_AUTOMATIC_REVIEWER_COUNT, officialSubagentOnDemandRoleCatalog, officialSubagentRoleCatalog, selectOfficialSubagentRole } from './agent-catalog.js';
 export function buildOfficialSubagentPrompt(input) {
     const maxThreads = clampThreads(input.maxThreads);
     const requestedSubagents = normalizeRequestedSubagents(input.requestedSubagents, input.slices.length);
-    const waveCount = requestedSubagents === 0 ? 0 : Math.ceil(requestedSubagents / maxThreads);
+    const firstWave = input.firstWave === undefined
+        ? Math.min(requestedSubagents, maxThreads)
+        : normalizeRequestedSubagents(input.firstWave, 0);
+    const waveCount = input.waveCount === undefined
+        ? firstWave > 0 ? Math.ceil(requestedSubagents / firstWave) : 0
+        : normalizeRequestedSubagents(input.waveCount, 0);
     const parentDecompositionRequired = input.decompositionStatus === 'parent_required';
     const requestedSource = input.requestedSubagentsSource === 'route_contract'
         ? 'route_contract'
@@ -14,7 +19,7 @@ export function buildOfficialSubagentPrompt(input) {
         ? `${requestedSubagents} (explicit operator request)`
         : requestedSource === 'route_contract'
             ? `${requestedSubagents} (route-owned exact orchestration contract)`
-            : `${requestedSubagents} (risk-based automatic count; two independent children are the non-trivial default; keep the plan and evidence count exact)`;
+            : `${requestedSubagents} (dynamic automatic target; keep the final decomposed plan and evidence count exact)`;
     const triwiki = renderBoundedTriwikiAttention(input.triwikiAttention);
     const resolvedSlices = input.slices.map((slice) => ({
         slice,
@@ -27,6 +32,10 @@ export function buildOfficialSubagentPrompt(input) {
             requiresWrite: slice.readOnly !== true
         })
     }));
+    const sliceSafety = validateOfficialSubagentSlices(resolvedSlices.map(({ slice, agentName }) => ({
+        ...slice,
+        agent: agentName
+    })));
     const catalog = renderAgentCatalog([
         ...resolvedSlices.map((row) => row.agentName),
         ...(input.recommendedAgents || [])
@@ -61,16 +70,20 @@ Subagent rules:
 - use gpt-5.6-terra with medium reasoning for long-context analysis and direct Computer Use, Browser/Chrome, or image-generation execution
 - split mixed work when possible: Terra gathers or operates, Sol High implements, and Sol Max judges; when one slice cannot be split safely, judgment takes priority
 - never assign Luna to long-context, exploration, review, debugging, planning, or tool-heavy work
-- automatic fan-out is selected before execution: two independent children for non-trivial work,
-  and at most ${MAX_AUTOMATIC_SUBAGENT_COUNT} only for critical multi-domain risk; trivial Answer/DFix work is filtered before this route
-- automatic reviewer-only fan-out is capped at ${MAX_AUTOMATIC_REVIEWER_COUNT} for ordinary work; critical multi-domain review may use the overall cap of ${MAX_AUTOMATIC_SUBAGENT_COUNT}
+- 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
+- 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}
+- max open agent threads: ${maxThreads} (hard cap, never a utilization target)
+- selected first-wave concurrency: ${firstWave}
 - planned waves: ${waveCount}
+- before every wave compute C_t = min(ready DAG width, disjoint ownership, verifier capacity, tool concurrency, available thread slots after reservations, marginal-useful workers); launch n_t <= C_t only while marginal useful throughput stays positive
+- capacity snapshot: ${renderCapacity(input.capacity)}
 - max depth: 1
 - subagents must not spawn subagents
 - parallel writes require disjoint paths
 - if paths overlap, run those slices serially
+- reject duplicate slice fingerprints and homogeneous clone work; diversity may come from roles, disjoint shards, or different tool surfaces
+- security, database, release, authorization, and irreversible-effect checks are protected strata; aggregate speed or accuracy never offsets a failed protected gate
 - wait for every requested subagent before integrating
 - close completed threads after collecting results
 ${parentDecompositionRequired ? `- decomposition status: parent_required
@@ -80,7 +93,11 @@ ${requestedSource === 'operator'
         ? '- the explicit operator count is authoritative; if it cannot be defended safely, block and report instead of silently changing it'
         : requestedSource === 'route_contract'
             ? '- the route-owned exact count is authoritative; preserve it and follow the route-specific orchestration contract'
-            : '- if fewer defensible slices exist, reduce the delegation plan and requested count before execution; never increase automatically beyond the selected count'}` : '- decomposition status: ready'}
+            : `- after decomposition, resize the automatic plan to the useful independent slice count, bounded by C_t and ${MAX_AUTOMATIC_SUBAGENT_COUNT}; update plan/evidence before the first spawn
+- if fewer defensible slices exist, reduce the count; if more defensible slices and positive capacity exist, increase only within the automatic ceiling`}` : '- decomposition status: ready'}
+
+Slice safety:
+${renderSliceSafety(sliceSafety, parentDecompositionRequired)}
 
 Central TriWiki context:
 ${triwiki}
@@ -112,6 +129,61 @@ Final parent output:
 - keep completion summary and Honest Mode wording inside the JSON fields; do not add prose outside the object
 `.trim();
 }
+export function validateOfficialSubagentSlices(slices) {
+    const blockers = [];
+    const duplicateSliceIds = [];
+    const overlappingWriteScopes = [];
+    const unassignedWriteScopes = [];
+    const fingerprints = new Map();
+    for (const slice of slices) {
+        const id = String(slice.id || '').trim() || 'unnamed';
+        const paths = normalizedPaths(slice.paths);
+        const fingerprint = [
+            normalizedIntent(slice.title),
+            normalizedIntent(slice.description),
+            String(slice.agent || slice.kind || '').trim().toLowerCase(),
+            paths.join('|'),
+            slice.readOnly === true ? 'read-only' : 'write'
+        ].join('::');
+        const ids = fingerprints.get(fingerprint) || [];
+        ids.push(id);
+        fingerprints.set(fingerprint, ids);
+        if (slice.readOnly !== true && paths.length === 0)
+            unassignedWriteScopes.push(id);
+    }
+    for (const ids of fingerprints.values()) {
+        if (ids.length < 2)
+            continue;
+        duplicateSliceIds.push(ids);
+        blockers.push(`duplicate_slice_fingerprint:${ids.join(',')}`);
+    }
+    const writable = slices
+        .filter((slice) => slice.readOnly !== true)
+        .map((slice) => ({ id: String(slice.id || '').trim() || 'unnamed', paths: normalizedPaths(slice.paths) }));
+    for (let leftIndex = 0; leftIndex < writable.length; leftIndex += 1) {
+        for (let rightIndex = leftIndex + 1; rightIndex < writable.length; rightIndex += 1) {
+            const left = writable[leftIndex];
+            const right = writable[rightIndex];
+            const overlap = firstOverlappingPath(left.paths, right.paths);
+            if (!overlap)
+                continue;
+            overlappingWriteScopes.push({ left: left.id, right: right.id, path: overlap });
+            blockers.push(`overlapping_write_scope:${left.id}:${right.id}:${overlap}`);
+        }
+    }
+    if (writable.length > 1) {
+        for (const id of unassignedWriteScopes)
+            blockers.push(`unassigned_parallel_write_scope:${id}`);
+    }
+    return {
+        safe: blockers.length === 0,
+        blockers: [...new Set(blockers)],
+        duplicate_slice_ids: duplicateSliceIds,
+        overlapping_write_scopes: overlappingWriteScopes,
+        unassigned_write_scopes: unassignedWriteScopes,
+        distinct_role_count: new Set(slices.map((slice) => String(slice.agent || slice.kind || '').trim()).filter(Boolean)).size
+    };
+}
 function renderBoundedTriwikiAttention(value) {
     if (!value?.available || value.anchors.length === 0) {
         return [
@@ -144,6 +216,64 @@ function renderAgentCatalog(requested) {
         })
     ].join('\n');
 }
+function renderCapacity(capacity) {
+    if (!capacity)
+        return 'parent recomputes after decomposition; no pre-decomposition capacity snapshot available';
+    return JSON.stringify({
+        formula: capacity.formula,
+        selected_capacity: capacity.selected_capacity,
+        available_thread_slots: capacity.available_thread_slots,
+        limiting_factors: capacity.limiting_factors,
+        reservations: capacity.reservations,
+        marginal_useful_throughput_positive: capacity.marginal_useful_throughput_positive
+    });
+}
+function renderSliceSafety(value, parentDecompositionRequired) {
+    if (parentDecompositionRequired) {
+        return [
+            '- pending parent decomposition; validate duplicate fingerprints, write-scope overlap, ownership assignment, and role/shard/tool diversity before spawning',
+            '- unsafe decomposition must be merged, serialized, or blocked before any child starts'
+        ].join('\n');
+    }
+    if (value.safe) {
+        return `- validated safe: ${value.distinct_role_count} distinct role(s), no duplicate slice fingerprint, and no overlapping write scope`;
+    }
+    return `- blocked: ${value.blockers.join(', ')}`;
+}
+function normalizedIntent(value) {
+    return String(value || '')
+        .toLowerCase()
+        .replace(/[^a-z0-9가-힣]+/g, ' ')
+        .trim()
+        .replace(/\s+/g, ' ');
+}
+function normalizedPaths(paths) {
+    return [...new Set((paths || [])
+            .map((entry) => String(entry || '').trim().replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, ''))
+            .filter(Boolean))]
+        .sort();
+}
+function firstOverlappingPath(leftPaths, rightPaths) {
+    for (const left of leftPaths) {
+        for (const right of rightPaths) {
+            const leftPrefix = pathPrefix(left);
+            const rightPrefix = pathPrefix(right);
+            if (leftPrefix === '.'
+                || rightPrefix === '.'
+                || leftPrefix === rightPrefix
+                || leftPrefix.startsWith(`${rightPrefix}/`)
+                || rightPrefix.startsWith(`${leftPrefix}/`)) {
+                return left.length <= right.length ? left : right;
+            }
+        }
+    }
+    return null;
+}
+function pathPrefix(value) {
+    const wildcard = value.search(/[?*[{]/);
+    const prefix = wildcard >= 0 ? value.slice(0, wildcard) : value;
+    return prefix.replace(/\/+$/, '') || '.';
+}
 function clampThreads(value) {
     const parsed = Number(value);
     if (!Number.isFinite(parsed))
@@ -156,4 +286,3 @@ function normalizeRequestedSubagents(value, fallback) {
         return Math.max(0, Math.min(HARD_NARUTO_MAX_THREADS, fallback));
     return Math.max(0, Math.min(HARD_NARUTO_MAX_THREADS, Math.floor(parsed)));
 }
-//# sourceMappingURL=official-subagent-prompt.js.map

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

@@ -38,8 +38,7 @@ export async function runOfficialSubagentWorkflow(input) {
         max_depth: 1,
         parent_model: NARUTO_PARENT_MODEL,
         parent_reasoning_effort: NARUTO_PARENT_EFFORT,
-        session_scope: input.sessionKey || null,
-        legacy_process_swarm_used: false
+        session_scope: input.sessionKey || null
     };
     if (input.appSession) {
         return {
@@ -126,4 +125,3 @@ export async function runOfficialSubagentWorkflow(input) {
         completion_evidence: false
     };
 }
-//# sourceMappingURL=official-subagent-runner.js.map

package/dist/core/subagents/subagent-evidence.js

@@ -660,4 +660,3 @@ function firstText(...values) {
     }
     return '';
 }
-//# sourceMappingURL=subagent-evidence.js.map

package/dist/core/subagents/terminology.js

@@ -13,4 +13,3 @@ export const DEPRECATED_AGENT_TERMS = Object.freeze([
     'active pool',
     'worker swarm'
 ]);
-//# sourceMappingURL=terminology.js.map

package/dist/core/subagents/thread-budget.js

@@ -1,15 +1,52 @@
 export const DEFAULT_NARUTO_MAX_THREADS = 12;
 export const HARD_NARUTO_MAX_THREADS = 32;
 export const DEFAULT_NARUTO_REQUESTED_SUBAGENTS = 2;
+export const DEFAULT_NARUTO_PARENT_THREAD_RESERVATION = 1;
+export const DEFAULT_NARUTO_REVIEWER_THREAD_RESERVATION = 1;
 export function resolveSubagentThreadBudget(input = {}) {
     const requested = clamp(input.requested ?? input.independentSliceCount ?? DEFAULT_NARUTO_REQUESTED_SUBAGENTS, 1, HARD_NARUTO_MAX_THREADS);
     const configured = clamp(input.configuredMaxThreads ?? DEFAULT_NARUTO_MAX_THREADS, 1, HARD_NARUTO_MAX_THREADS);
+    const parentThreads = clampNonNegative(input.parentReservedThreads ?? DEFAULT_NARUTO_PARENT_THREAD_RESERVATION, HARD_NARUTO_MAX_THREADS);
+    const reviewerThreads = clampNonNegative(input.reviewerReservedThreads ?? DEFAULT_NARUTO_REVIEWER_THREAD_RESERVATION, HARD_NARUTO_MAX_THREADS);
+    const activeThreads = clampNonNegative(input.activeThreadCount ?? 0, HARD_NARUTO_MAX_THREADS);
+    const availableThreadSlots = Math.max(0, configured - parentThreads - reviewerThreads - activeThreads);
+    const marginalUsefulThroughputPositive = input.marginalUsefulThroughputPositive !== false;
+    const bounds = {
+        ready_dag_width: optionalCapacity(input.readyDagWidth, requested),
+        disjoint_ownership: optionalCapacity(input.disjointOwnershipCount, requested),
+        verifier_capacity: optionalCapacity(input.verifierCapacity, requested),
+        tool_concurrency: optionalCapacity(input.toolConcurrency, requested),
+        available_thread_slots: availableThreadSlots,
+        marginal_useful_workers: marginalUsefulThroughputPositive
+            ? optionalCapacity(input.marginalUsefulWorkers, requested)
+            : 0,
+        requested_subagents: requested
+    };
+    const selectedCapacity = Math.min(...Object.values(bounds));
+    const limitingFactors = Object.entries(bounds)
+        .filter(([, value]) => value === selectedCapacity)
+        .map(([factor]) => factor);
     return {
         requestedSubagents: requested,
         maxThreads: configured,
-        firstWave: Math.min(requested, configured),
-        waveCount: Math.ceil(requested / configured),
-        maxDepth: 1
+        firstWave: selectedCapacity,
+        waveCount: selectedCapacity > 0 ? Math.ceil(requested / selectedCapacity) : 0,
+        maxDepth: 1,
+        capacity: {
+            formula: 'min_ready_dag_disjoint_verifier_tools_available_marginal',
+            max_threads_is_cap_not_target: true,
+            selected_capacity: selectedCapacity,
+            available_thread_slots: availableThreadSlots,
+            limiting_factors: limitingFactors,
+            bounds,
+            reservations: {
+                parent_threads: parentThreads,
+                reviewer_threads: reviewerThreads,
+                active_threads: activeThreads
+            },
+            marginal_useful_throughput_positive: marginalUsefulThroughputPositive,
+            exhausted: requested > 0 && selectedCapacity === 0
+        }
     };
 }
 function clamp(value, minimum, maximum) {
@@ -18,4 +55,14 @@ function clamp(value, minimum, maximum) {
         return minimum;
     return Math.max(minimum, Math.min(maximum, Math.floor(parsed)));
 }
-//# sourceMappingURL=thread-budget.js.map
+function clampNonNegative(value, maximum) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed))
+        return 0;
+    return Math.max(0, Math.min(maximum, Math.floor(parsed)));
+}
+function optionalCapacity(value, fallback) {
+    if (value === undefined || value === null || value === '')
+        return fallback;
+    return clampNonNegative(value, HARD_NARUTO_MAX_THREADS);
+}

package/dist/core/subagents/triwiki-attention.js

@@ -165,4 +165,3 @@ function asRecord(value) {
 function text(value) {
     return typeof value === 'string' ? value.trim() : '';
 }
-//# sourceMappingURL=triwiki-attention.js.map

package/dist/core/super-search/doctor.js

@@ -71,7 +71,7 @@ export function printSuperSearchDoctorReport(report, json) {
         console.log(JSON.stringify(report, null, 2));
         return;
     }
-    console.log(`Super-Search doctor: ${report.status}; xAI/Grok is not required.`);
+    console.log(`Super-Search doctor: ${report.status}; provider-specific credentials are not required.`);
     if (report.blockers.length) {
         console.log(`Blockers: ${report.blockers.join(', ')}`);
         console.log(`Next actions: ${report.next_actions.join('; ')}`);
@@ -94,4 +94,3 @@ async function readLocalSmokeFreshness(reportPath) {
         return { available: false, fresh: false };
     return { available: true, fresh: Date.now() - stat.mtimeMs < 60 * 60 * 1000 };
 }
-//# sourceMappingURL=doctor.js.map

package/dist/core/super-search/index.js

@@ -1,3 +1,2 @@
 export * from './types.js';
 export * from './runtime.js';
-//# sourceMappingURL=index.js.map

package/dist/core/super-search/local-http-smoke.js

@@ -95,4 +95,3 @@ async function closeServerWithReport(server, reportPath, report, onClosed) {
     await writeJsonAtomic(reportPath, finalReport);
     return finalReport;
 }
-//# sourceMappingURL=local-http-smoke.js.map

package/dist/core/super-search/runtime-helpers.js

@@ -552,4 +552,3 @@ export function buildAttemptLedger(providerPlan, mode, blockers, warnings) {
 export function extractFirstUrl(text) {
     return text.match(/https?:\/\/[^\s)"']+/i)?.[0] || null;
 }
-//# sourceMappingURL=runtime-helpers.js.map

package/dist/core/super-search/runtime.js

@@ -422,4 +422,3 @@ async function raceSuperSearchOperation(promise, deadlineEpochMs) {
             clearTimeout(timer);
     }
 }
-//# sourceMappingURL=runtime.js.map

package/dist/core/super-search/source-records.js

@@ -134,4 +134,3 @@ export function classifyAuthority(raw) {
         return 'D';
     return 'C';
 }
-//# sourceMappingURL=source-records.js.map

package/dist/core/super-search/types.js

@@ -1,3 +1,2 @@
 export const SUPER_SEARCH_PROOF_SCHEMA = 'sks.super-search-proof.v1';
 export const SUPER_SEARCH_GATE_SCHEMA = 'sks.super-search-gate.v1';
-//# sourceMappingURL=types.js.map