sneakoscope 8.0.2 → 8.0.4

package/dist/core/safety/mutation-ledger.js

@@ -14,7 +14,6 @@ export const MUTATION_KINDS = [
     'process_kill',
     'codex_app_flag_change',
     'codex_lb_auth_change',
-    'zellij_install',
     'database_write',
     'skill_snapshot_promotion'
 ];
@@ -30,7 +29,6 @@ const KIND_TO_SCOPE = {
     process_kill: 'codex_app_process',
     codex_app_flag_change: 'global_codex_config',
     codex_lb_auth_change: 'codex_lb_auth',
-    zellij_install: 'zellij_install',
     database_write: 'project_files',
     skill_snapshot_promotion: 'skill_snapshot_promotion'
 };

package/dist/core/search-visibility/discovery.js

@@ -79,7 +79,7 @@ export async function discoverSiteInventory(ctx, detected) {
         locale_candidates: discoverLocales(files, htmlFiles),
         metadata_helpers: files.filter((file) => /(seo|metadata|schema|json-ld|structured-data|canonical|sitemap|robots)/i.test(file)).slice(0, 100),
         structured_data_sources: files.filter((file) => /(schema|json-ld|structured-data|ld-json)/i.test(file)).slice(0, 100),
-        live_url_checked: Boolean(ctx.origin && !ctx.offline),
+        live_url_checked: false,
         browser_checked: false,
         generated_at: new Date().toISOString(),
     };

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

@@ -273,6 +273,18 @@ async function verifyMarketingMutationFlow(mode, mission, plan, options) {
         http_verified: false,
         browser_verified: false,
         production_verified: false,
+        http_evidence: {
+            attempted: false,
+            verified: false,
+            requested_url: options.url,
+            final_url: null,
+            status_code: null,
+            content_type: null,
+            content_bytes: null,
+            content_sha256: null,
+            observed_at: null,
+            error: 'marketing_flow_does_not_perform_production_http_verification',
+        },
         measured_outcome: 'pending',
         checked_artifacts: requiredStatus.map((item) => ({ path: item.path, ok: item.present, message: item.present ? 'present' : 'missing' })),
         blockers,

package/dist/core/search-visibility/verifier.js

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { createHash } from 'node:crypto';
 import { exists } from '../fsx.js';
 import { SEARCH_VISIBILITY_DIR, routeForMode } from './mission.js';
 const COMMON_REQUIRED = [
@@ -9,7 +10,7 @@ const COMMON_REQUIRED = [
     'robots-policy.json',
     'structured-data-ledger.json',
 ];
-export async function verifySearchVisibility(ctx, inventory, mission) {
+export async function verifySearchVisibility(ctx, inventory, mission, dependencies = {}) {
     const route = routeForMode(ctx.mode);
     const required = [
         ...COMMON_REQUIRED,
@@ -23,9 +24,17 @@ export async function verifySearchVisibility(ctx, inventory, mission) {
         }))
         : [];
     const blockers = checked.filter((item) => !item.ok).map((item) => `missing_artifact:${item.path}`);
-    const productionVerified = Boolean(ctx.origin && !ctx.offline);
+    const httpEvidence = await verifyProductionHttp(ctx, dependencies);
+    const productionVerified = httpEvidence.verified === true
+        && httpEvidence.status_code !== null
+        && httpEvidence.status_code >= 200
+        && httpEvidence.status_code < 300
+        && Boolean(httpEvidence.content_type)
+        && Boolean(httpEvidence.content_sha256)
+        && Boolean(httpEvidence.observed_at);
     const unverified = [
-        ...(ctx.origin && !ctx.offline ? [] : ['production_http_not_verified']),
+        ...(productionVerified ? [] : ['production_http_not_verified']),
+        ...(httpEvidence.error ? [`production_http_verification_failed:${httpEvidence.error}`] : []),
         ...(ctx.framework === 'unsupported' ? ['framework_specific_mutation_not_verified'] : []),
         ...(ctx.mode === 'geo' ? ['external_ai_answer_observation_not_verified', 'measured_outcome_pending'] : ['search_ranking_or_traffic_outcome_not_measured']),
         ...(!ctx.strict ? ['strict_mode_not_requested'] : []),
@@ -46,12 +55,112 @@ export async function verifySearchVisibility(ctx, inventory, mission) {
         http_verified: productionVerified,
         browser_verified: false,
         production_verified: productionVerified,
+        http_evidence: httpEvidence,
         measured_outcome: 'pending',
         checked_artifacts: checked,
         blockers,
         unverified,
     };
 }
+async function verifyProductionHttp(ctx, dependencies) {
+    const requestedUrl = normalizeHttpUrl(ctx.origin);
+    if (ctx.offline || !requestedUrl) {
+        return emptyHttpEvidence(ctx.origin, ctx.offline ? null : 'invalid_or_missing_http_origin');
+    }
+    const fetchImpl = dependencies.fetch || globalThis.fetch;
+    if (typeof fetchImpl !== 'function')
+        return emptyHttpEvidence(requestedUrl, 'fetch_unavailable', true);
+    const observedAt = (dependencies.now || (() => new Date()))().toISOString();
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), dependencies.timeoutMs ?? 10_000);
+    try {
+        const response = await fetchImpl(requestedUrl, {
+            method: 'GET',
+            redirect: 'follow',
+            signal: controller.signal,
+            headers: {
+                accept: 'text/html,application/xhtml+xml;q=0.9',
+                'user-agent': 'Sneakoscope-Search-Visibility-Verifier/8',
+            },
+        });
+        const body = await response.text();
+        const contentType = normalizedContentType(response.headers.get('content-type'));
+        const bytes = Buffer.byteLength(body, 'utf8');
+        const contentSha256 = bytes > 0 ? createHash('sha256').update(body).digest('hex') : null;
+        const error = httpVerificationError(response.status, contentType, body);
+        return {
+            attempted: true,
+            verified: error === null,
+            requested_url: requestedUrl,
+            final_url: response.url || requestedUrl,
+            status_code: response.status,
+            content_type: contentType,
+            content_bytes: bytes,
+            content_sha256: contentSha256,
+            observed_at: observedAt,
+            error,
+        };
+    }
+    catch (error) {
+        return {
+            ...emptyHttpEvidence(requestedUrl, error instanceof Error && error.name === 'AbortError' ? 'request_timeout' : 'request_failed', true),
+            observed_at: observedAt,
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function normalizeHttpUrl(origin) {
+    if (!origin)
+        return null;
+    try {
+        const url = new URL(origin);
+        if (url.protocol !== 'http:' && url.protocol !== 'https:')
+            return null;
+        return url.href;
+    }
+    catch {
+        return null;
+    }
+}
+function normalizedContentType(value) {
+    const normalized = String(value || '').split(';', 1)[0]?.trim().toLowerCase() || '';
+    return normalized || null;
+}
+function httpVerificationError(status, contentType, body) {
+    if (status < 200 || status >= 300)
+        return `http_status_${status}`;
+    if (contentType !== 'text/html' && contentType !== 'application/xhtml+xml')
+        return 'non_html_content_type';
+    if (!body.trim())
+        return 'empty_response_body';
+    if (!/(?:<!doctype\s+html|<html\b)/i.test(body))
+        return 'html_document_marker_missing';
+    const visible = body
+        .replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, ' ')
+        .replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, ' ')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (visible.length < 20)
+        return 'insufficient_html_content';
+    return null;
+}
+function emptyHttpEvidence(requestedUrl, error, attempted = false) {
+    return {
+        attempted,
+        verified: false,
+        requested_url: requestedUrl,
+        final_url: null,
+        status_code: null,
+        content_type: null,
+        content_bytes: null,
+        content_sha256: null,
+        observed_at: null,
+        error,
+    };
+}
 export function expectedArtifactPath(missionId, artifact) {
     if (artifact.endsWith('-gate.json') || artifact === 'completion-proof.json')
         return `.sneakoscope/missions/${missionId}/${artifact}`;

package/dist/core/security/private-credential-file.js

@@ -0,0 +1,209 @@
+import fsp from 'node:fs/promises';
+import { constants as fsConstants } from 'node:fs';
+import { createHash, randomBytes } from 'node:crypto';
+import path from 'node:path';
+import { assertTestHomeWriteAllowed } from '../fsx.js';
+import { ensureConfinedDirectory, inspectConfinedPath, isLexicallyConfined } from '../managed-path-safety.js';
+export class PrivateCredentialFileError extends Error {
+    code;
+    file;
+    label;
+    constructor(code, file, label) {
+        super(`${label}_${code}:${file}`);
+        this.name = 'PrivateCredentialFileError';
+        this.code = code;
+        this.file = file;
+        this.label = label;
+    }
+}
+export async function readPrivateCredentialFile(boundary, file, label, opts = {}) {
+    if (opts.maxBytes !== undefined && (!Number.isSafeInteger(opts.maxBytes) || opts.maxBytes < 0)) {
+        throw new RangeError('maxBytes must be a non-negative safe integer');
+    }
+    if (!isLexicallyConfined(boundary, file))
+        throw new PrivateCredentialFileError('outside_boundary', file, label);
+    const inspected = await inspectConfinedPath(boundary, file);
+    if (!inspected.exists)
+        throw new PrivateCredentialFileError('missing', file, label);
+    if (inspected.leafSymlink || !inspected.stat?.isFile()) {
+        throw new PrivateCredentialFileError('not_regular', file, label);
+    }
+    if ((inspected.stat.mode & 0o777) !== 0o600) {
+        throw new PrivateCredentialFileError('mode_not_0600', file, label);
+    }
+    const expectedUid = typeof process.getuid === 'function' ? process.getuid() : null;
+    if (expectedUid !== null && inspected.stat.uid !== expectedUid) {
+        throw new PrivateCredentialFileError('owner_mismatch', file, label);
+    }
+    let handle = null;
+    try {
+        handle = await fsp.open(file, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
+        const before = await handle.stat();
+        if (!before.isFile()
+            || before.dev !== inspected.stat.dev
+            || before.ino !== inspected.stat.ino
+            || (before.mode & 0o777) !== 0o600
+            || (expectedUid !== null && before.uid !== expectedUid)) {
+            throw new PrivateCredentialFileError('identity_mismatch', file, label);
+        }
+        if (opts.maxBytes !== undefined && before.size > opts.maxBytes) {
+            throw new PrivateCredentialFileError('too_large', file, label);
+        }
+        const bytes = opts.maxBytes === undefined
+            ? await handle.readFile()
+            : await readBounded(handle, opts.maxBytes, file, label);
+        const after = await handle.stat();
+        const pathAfter = await inspectConfinedPath(boundary, file);
+        if (!pathAfter.exists
+            || pathAfter.leafSymlink
+            || !pathAfter.stat?.isFile()
+            || (after.mode & 0o777) !== 0o600
+            || (pathAfter.stat.mode & 0o777) !== 0o600
+            || (expectedUid !== null && (after.uid !== expectedUid || pathAfter.stat.uid !== expectedUid))
+            || before.dev !== after.dev
+            || before.ino !== after.ino
+            || before.size !== after.size
+            || before.mtimeMs !== after.mtimeMs
+            || after.dev !== pathAfter.stat.dev
+            || after.ino !== pathAfter.stat.ino) {
+            throw new PrivateCredentialFileError('changed_during_verification', file, label);
+        }
+        return {
+            bytes,
+            sha256: createHash('sha256').update(bytes).digest('hex')
+        };
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+async function readBounded(handle, maxBytes, file, label) {
+    const chunks = [];
+    let total = 0;
+    for (;;) {
+        const chunk = Buffer.allocUnsafe(Math.min(16 * 1024, maxBytes + 1 - total));
+        const { bytesRead } = await handle.read(chunk, 0, chunk.length, null);
+        if (bytesRead === 0)
+            break;
+        total += bytesRead;
+        if (total > maxBytes)
+            throw new PrivateCredentialFileError('too_large', file, label);
+        chunks.push(chunk.subarray(0, bytesRead));
+    }
+    return Buffer.concat(chunks, total);
+}
+export async function hardenPrivateCredentialFileMode(boundary, file, label) {
+    if (!isLexicallyConfined(boundary, file))
+        throw new PrivateCredentialFileError('outside_boundary', file, label);
+    const inspected = await inspectConfinedPath(boundary, file);
+    if (!inspected.exists)
+        throw new PrivateCredentialFileError('missing', file, label);
+    if (inspected.leafSymlink || !inspected.stat?.isFile()) {
+        throw new PrivateCredentialFileError('not_regular', file, label);
+    }
+    const expectedUid = typeof process.getuid === 'function' ? process.getuid() : null;
+    if (expectedUid !== null && inspected.stat.uid !== expectedUid) {
+        throw new PrivateCredentialFileError('owner_mismatch', file, label);
+    }
+    let handle = null;
+    try {
+        handle = await fsp.open(file, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
+        const before = await handle.stat();
+        if (!before.isFile()
+            || before.dev !== inspected.stat.dev
+            || before.ino !== inspected.stat.ino
+            || (expectedUid !== null && before.uid !== expectedUid)) {
+            throw new PrivateCredentialFileError('identity_mismatch', file, label);
+        }
+        await handle.chmod(0o600);
+        const after = await handle.stat();
+        if ((after.mode & 0o777) !== 0o600 || after.dev !== before.dev || after.ino !== before.ino) {
+            throw new PrivateCredentialFileError('identity_mismatch', file, label);
+        }
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+export async function writePrivateTextAtomic(boundary, file, text, label) {
+    if (!isLexicallyConfined(boundary, file))
+        throw new PrivateCredentialFileError('outside_boundary', file, label);
+    assertTestHomeWriteAllowed(file);
+    await ensureConfinedDirectory(boundary, path.dirname(file));
+    const before = await inspectConfinedPath(boundary, file);
+    if (before.exists && (before.leafSymlink || !before.stat?.isFile())) {
+        throw new PrivateCredentialFileError('not_regular', file, label);
+    }
+    if (before.stat && (before.stat.mode & 0o777) !== 0o600) {
+        throw new PrivateCredentialFileError('mode_not_0600', file, label);
+    }
+    const expectedUid = typeof process.getuid === 'function' ? process.getuid() : null;
+    if (before.stat && expectedUid !== null && before.stat.uid !== expectedUid) {
+        throw new PrivateCredentialFileError('owner_mismatch', file, label);
+    }
+    const temp = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.${randomBytes(8).toString('hex')}.tmp`);
+    let handle = null;
+    try {
+        handle = await fsp.open(temp, fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL | fsConstants.O_NOFOLLOW, 0o600);
+        await handle.chmod(0o600);
+        const tempStat = await handle.stat();
+        if (!tempStat.isFile()
+            || (tempStat.mode & 0o777) !== 0o600
+            || (expectedUid !== null && tempStat.uid !== expectedUid)) {
+            throw new PrivateCredentialFileError('identity_mismatch', temp, label);
+        }
+        await handle.writeFile(text, 'utf8');
+        await handle.sync();
+        await handle.close();
+        handle = null;
+        const current = await inspectConfinedPath(boundary, file);
+        const unchanged = before.exists === current.exists
+            && (!before.exists || (!current.leafSymlink
+                && current.stat?.isFile() === true
+                && before.stat?.dev === current.stat.dev
+                && before.stat?.ino === current.stat.ino));
+        if (!unchanged)
+            throw new PrivateCredentialFileError('changed_during_verification', file, label);
+        await fsp.rename(temp, file);
+        const parentHandle = await fsp.open(path.dirname(file), fsConstants.O_RDONLY);
+        try {
+            await parentHandle.sync();
+        }
+        finally {
+            await parentHandle.close();
+        }
+        await readPrivateCredentialFile(boundary, file, label);
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+        await fsp.rm(temp, { force: true }).catch(() => undefined);
+    }
+}
+export async function createPrivateTextExclusive(boundary, file, text, label, opts = {}) {
+    if (!isLexicallyConfined(boundary, file))
+        throw new PrivateCredentialFileError('outside_boundary', file, label);
+    assertTestHomeWriteAllowed(file);
+    await ensureConfinedDirectory(boundary, path.dirname(file));
+    const temp = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.${randomBytes(8).toString('hex')}.claim`);
+    let handle = null;
+    try {
+        handle = await fsp.open(temp, fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL | fsConstants.O_NOFOLLOW, 0o600);
+        await handle.writeFile(text, 'utf8');
+        await handle.sync();
+        await handle.close();
+        handle = null;
+        await opts.beforePublish?.(temp);
+        await fsp.link(temp, file);
+        await readPrivateCredentialFile(boundary, file, label);
+        return true;
+    }
+    catch (error) {
+        if (error?.code === 'EEXIST')
+            return false;
+        throw error;
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+        await fsp.rm(temp, { force: true }).catch(() => undefined);
+    }
+}

package/dist/core/session/project-namespace.js

@@ -28,7 +28,6 @@ export async function buildProjectNamespace(input = {}) {
         mission_id: missionId,
         mission_namespace_id: missionNamespaceId,
         orchestrator_id: orchestratorId,
-        zellij_prefix: namespaceForPaths,
         temp_dir: path.join(os.tmpdir(), namespaceForPaths),
         lock_dir: path.join(projectRoot, '.sneakoscope', 'locks', rootHash),
         artifact_dir: missionId
@@ -40,10 +39,6 @@ export function namespacedAgentSessionId(input) {
     const suffix = input.index === undefined ? '' : `-${String(input.index).padStart(2, '0')}`;
     return `${input.agentId}-${input.missionId}-${input.rootHash}${suffix}`;
 }
-export function namespacedZellijSessionName(namespace, label = 'work') {
-    const raw = `${namespace.zellij_prefix}-${label}`;
-    return raw.replace(/[^A-Za-z0-9_.:-]+/g, '-').slice(0, 80);
-}
 export async function writeProjectNamespaceArtifact(artifactRoot, namespace) {
     const file = path.join(artifactRoot, 'project-session-namespace.json');
     await writeJsonAtomic(file, namespace);

package/dist/core/skills/skill-agent-metadata.js

@@ -1,3 +1,4 @@
+import { escapeRegExp } from '../text/regex.js';
 const OFFICIAL_TOP_LEVEL_KEYS = new Set(['interface', 'policy', 'dependencies']);
 const OFFICIAL_INTERFACE_KEYS = new Set([
     'display_name',
@@ -343,6 +344,3 @@ function parseYamlScalar(rawValue) {
 function yamlString(value) {
     return JSON.stringify(value);
 }
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}

package/dist/core/strategy/adhd-orchestrating-gate.js

@@ -79,7 +79,6 @@ export function buildDopamineOrchestrationArtifacts(gate) {
             schema: MICRO_WIN_TASK_BOARD_SCHEMA,
             generated_at: gate.generated_at,
             summary_available: true,
-            zellij_summary_available: true,
             items: gate.micro_wins.map((task) => ({
                 id: task.id,
                 title: task.title,

package/dist/core/subagents/agent-catalog.js

@@ -1,17 +1,16 @@
 import { MANAGED_OFFICIAL_SUBAGENT_ROLES, managedOfficialSubagentRoleByName } from '../managed-assets/managed-assets-manifest.js';
-import { decideNarutoConcurrency } from '../naruto/naruto-concurrency-governor.js';
 import { decideSubagentModel } from './model-policy.js';
-import { DEFAULT_NARUTO_MAX_THREADS } from './thread-budget.js';
+import { HARD_NARUTO_MAX_THREADS } from './thread-budget.js';
 import { escapeRegExp } from '../text/regex.js';
 export const DEFAULT_AUTOMATIC_SUBAGENT_COUNT = 4;
 export const PARALLEL_AUTOMATIC_SUBAGENT_COUNT = 6;
 export const LARGE_SCALE_AUTOMATIC_SUBAGENT_COUNT = 8;
-export const MAX_AUTOMATIC_SUBAGENT_COUNT = 12;
+export const MAX_AUTOMATIC_SUBAGENT_COUNT = HARD_NARUTO_MAX_THREADS;
 export const MAX_AUTOMATIC_REVIEWER_COUNT = 2;
 export const MAX_CRITICAL_AUTOMATIC_REVIEWER_COUNT = 3;
 export const MASS_PARALLEL_AUTOMATIC_SUBAGENT_COUNT = 16;
-export const MAX_MASS_AUTOMATIC_SUBAGENT_COUNT = 64;
-export const MAX_ON_DEMAND_SUBAGENT_ROLE_COUNT = MAX_AUTOMATIC_SUBAGENT_COUNT;
+export const MAX_MASS_AUTOMATIC_SUBAGENT_COUNT = HARD_NARUTO_MAX_THREADS;
+export const MAX_ON_DEMAND_SUBAGENT_ROLE_COUNT = 25;
 export function officialSubagentRoleCatalog() {
     return MANAGED_OFFICIAL_SUBAGENT_ROLES.map(roleSummary);
 }
@@ -74,7 +73,7 @@ export function recommendOfficialSubagentRoles(input = {}) {
     if (ranked.length)
         return unique(ranked).slice(0, limit);
     const lane = decideSubagentModel({ description: text }).policy;
-    if (lane === 'terra_medium_context_tools')
+    if (lane === 'terra_max_context_tools')
         return ['explorer'];
     if (lane === 'luna_max_mechanical' && input.readOnly !== true)
         return ['worker'];
@@ -92,9 +91,9 @@ export function officialSubagentFanoutPolicy(input = {}) {
             ? 'operator'
             : 'automatic';
     const explicit = countSource !== 'automatic';
-    const explicitRequested = Number.isFinite(Number(input.requestedSubagents))
-        ? Math.max(1, Math.floor(Number(input.requestedSubagents)))
-        : DEFAULT_AUTOMATIC_SUBAGENT_COUNT;
+    const explicitRequested = input.requestedSubagents === undefined || input.requestedSubagents === null
+        ? DEFAULT_AUTOMATIC_SUBAGENT_COUNT
+        : boundedThreadCount(input.requestedSubagents, 'requested_subagents');
     const automatic = automaticSubagentFanout({
         ...(input.taskProfile === undefined ? {} : { taskProfile: input.taskProfile }),
         ...(input.goal === undefined ? {} : { goal: input.goal }),
@@ -146,13 +145,15 @@ function automaticSubagentFanout(input) {
     const massLane = decideSubagentModel({ description: text }).policy;
     const massParallel = MASS_PARALLEL_WORK_RE.test(text)
         && !NON_CHEAP_MASS_ACTION_RE.test(text)
-        && (massLane === 'luna_max_mechanical' || massLane === 'terra_medium_context_tools')
+        && (massLane === 'luna_max_mechanical' || massLane === 'terra_max_context_tools')
         && !reviewerOnly
         && !criticalMultiDomain;
     const automaticCeiling = massParallel ? MAX_MASS_AUTOMATIC_SUBAGENT_COUNT : MAX_AUTOMATIC_SUBAGENT_COUNT;
     const decomposedSliceCount = Number(input.independentSliceCount);
     const roleWidth = unique((input.suggestedRoles || []).map((role) => String(role || '').trim()).filter(Boolean)).length;
-    const frameBudget = clamp(Number(input.maxThreads) || DEFAULT_NARUTO_MAX_THREADS, 1, automaticCeiling);
+    if (input.maxThreads !== undefined && input.maxThreads !== null) {
+        boundedThreadCount(input.maxThreads, 'max_threads');
+    }
     if (Number.isFinite(decomposedSliceCount) && decomposedSliceCount > 0) {
         const reviewerCeiling = criticalMultiDomain
             ? MAX_CRITICAL_AUTOMATIC_REVIEWER_COUNT
@@ -208,38 +209,22 @@ function automaticSubagentFanout(input) {
         baseCount = Math.max(DEFAULT_AUTOMATIC_SUBAGENT_COUNT, Math.min(PARALLEL_AUTOMATIC_SUBAGENT_COUNT, roleWidth + 1));
         reason = 'role_width_parallel';
     }
-    const count = hardwareAwareAutomaticCount(baseCount, automaticCeiling, frameBudget, input.hardware);
+    const count = Math.min(baseCount, automaticCeiling);
     return {
         count,
         ceiling: automaticCeiling,
-        reason: count > baseCount ? `${reason}+hardware_capacity_boost` : reason,
+        reason,
         riskDomains,
         criticalMultiDomain: Boolean(criticalMultiDomain),
         massParallel
     };
 }
-function hardwareAwareAutomaticCount(baseCount, ceiling, frameBudget, hardware) {
-    const targetCeiling = clamp(ceiling, 1, ceiling);
-    const floor = clamp(baseCount, 1, targetCeiling);
-    try {
-        const decision = decideNarutoConcurrency({
-            requestedWorkers: targetCeiling,
-            totalWorkItems: targetCeiling,
-            parallelismMode: 'extreme',
-            maxThreads: frameBudget,
-            ...(hardware ? { hardware } : {})
-        });
-        const probe = decision.hardware;
-        const cpuCap = Math.max(1, Math.floor(probe.cpu_core_count * 0.75));
-        const freeGb = probe.free_memory_bytes / (1024 * 1024 * 1024);
-        const memCap = Math.max(1, Math.floor(Math.max(0.5, freeGb - 2) / 1.5));
-        const apiCap = Math.max(1, probe.remote_api_rate_limit_budget);
-        const safe = clamp(Math.min(cpuCap, memCap, apiCap, targetCeiling), 1, targetCeiling);
-        return Math.max(floor, safe);
-    }
-    catch {
-        return floor;
+function boundedThreadCount(value, label) {
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed < 1 || parsed > HARD_NARUTO_MAX_THREADS) {
+        throw new RangeError(`${label}_must_be_integer_1_to_${HARD_NARUTO_MAX_THREADS}:${String(value)}`);
     }
+    return parsed;
 }
 function isReviewerOnlyFanout(roles) {
     const normalized = unique(roles.map((role) => String(role || '').trim()).filter(Boolean));