sneakoscope 6.0.3 → 6.1.2

package/dist/core/security/high-risk-contracts.js

@@ -5,7 +5,7 @@ export const HIGH_RISK_CONTRACT_TARGETS = [
     'rollback apply',
     'doctor --fix',
     'update now --dry-run',
-    'db',
+    '$DB',
     'mad-sks'
 ];
 export const HIGH_RISK_CONTRACT_REPORT_SCHEMA = 'sks.high-risk-contracts.v2';
@@ -48,7 +48,7 @@ export function highRiskNegativeFixtures() {
             blocker: 'dry_run_attempted_real_install'
         },
         {
-            target: 'db',
+            target: '$DB',
             fixture: 'destructive_sql_without_mad_sks',
             input: { sql: 'DROP TABLE users;', madSksSqlPlane: false },
             blocker: 'destructive_sql_requires_mad_sks'
@@ -111,8 +111,8 @@ export function highRiskCliNegativeSmokeSpecs() {
             expected_blockers: ['dry_run_no_install_executed']
         },
         {
-            target: 'db',
-            argv: ['sks', 'db', 'check', '--sql', 'DROP TABLE users;', '--json'],
+            target: '$DB',
+            argv: ['sks', 'run', 'DROP TABLE users;', '--db', '--execute', '--json'],
             expected_blockers: ['destructive_sql_requires_mad_sks']
         },
         {
@@ -198,7 +198,7 @@ function blockersFromCliText(target, text, parsed, run) {
         blockers.push('doctor_touched_user_owned_file_without_sks_marker');
     else if (target === 'doctor --fix' && /(?:^|\s)user_owned_file_without_sks_marker(?:\s|$)/i.test(text))
         blockers.push('user_owned_file_without_sks_marker');
-    if (target === 'db' && /drop_table|drop_statement|destructive/i.test(text))
+    if (target === '$DB' && /drop_table|drop_statement|destructive/i.test(text))
         blockers.push('destructive_sql_requires_mad_sks');
     if (target === 'mad-sks' && /mad-sks-proof\.json|status.*missing|proof.*missing/i.test(text))
         blockers.push('mad_sks_read_back_proof_missing');
@@ -231,7 +231,7 @@ export function highRiskBlockers(target, input = {}) {
             return doctorFixBlockers(input);
         case 'update now --dry-run':
             return updateNowDryRunBlockers(input);
-        case 'db':
+        case '$DB':
             return dbBlockers(input);
         case 'mad-sks':
             return madSksBlockers(input);

package/dist/core/stop-gate/stop-gate-check.js

@@ -14,15 +14,34 @@ function normalizeRoute(route) {
 function rawGateToV1(raw, gatePath, route) {
     if (!raw)
         return null;
-    // If already canonical schema, cast
+    // Canonical input still needs runtime normalization. Older or hand-written
+    // gate files can omit optional arrays; malformed types must fail closed
+    // rather than throwing or being treated as empty.
     if (raw.schema === 'sks.stop-gate.v1') {
-        return raw;
+        return {
+            ...raw,
+            schema: 'sks.stop-gate.v1',
+            route: String(raw.route || route || 'Naruto'),
+            route_command: String(raw.route_command || '$Naruto'),
+            mission_id: String(raw.mission_id || ''),
+            gate_file: String(raw.gate_file || path.basename(gatePath)),
+            gate_abs_path: String(raw.gate_abs_path || gatePath),
+            status: String(raw.status || 'blocked'),
+            passed: raw.passed === true,
+            reason: typeof raw.reason === 'string' ? raw.reason : null,
+            terminal: raw.terminal === true,
+            terminal_state: String(raw.terminal_state || 'blocked'),
+            evidence: isRecord(raw.evidence) ? raw.evidence : {},
+            blockers: normalizedStringArray(raw.blockers, 'blockers_invalid'),
+            missing_fields: normalizedStringArray(raw.missing_fields, 'missing_fields_invalid'),
+            created_at: String(raw.created_at || raw.updated_at || nowIso()),
+        };
     }
     // Normalize from legacy naruto-gate.json / glm-naruto termination
     const passed = raw.passed === true;
     const status = passed ? 'passed' : (raw.status || 'blocked');
     const terminalState = raw.terminal_state || (passed ? 'completed' : 'blocked');
-    const evidence = raw.evidence || {};
+    const evidence = isRecord(raw.evidence) ? raw.evidence : {};
     return {
         schema: 'sks.stop-gate.v1',
         route: route || String(raw.route || 'Naruto'),
@@ -32,14 +51,28 @@ function rawGateToV1(raw, gatePath, route) {
         gate_abs_path: gatePath,
         status: status,
         passed,
+        reason: typeof raw.reason === 'string' ? raw.reason : null,
         terminal: raw.terminal === true || passed,
         terminal_state: terminalState,
         evidence: evidence,
-        blockers: Array.isArray(raw.blockers) ? raw.blockers : [],
-        missing_fields: Array.isArray(raw.missing_fields) ? raw.missing_fields : [],
+        blockers: normalizedStringArray(raw.blockers, 'blockers_invalid'),
+        missing_fields: normalizedStringArray(raw.missing_fields, 'missing_fields_invalid'),
         created_at: String(raw.created_at || raw.updated_at || nowIso()),
     };
 }
+function normalizedStringArray(value, invalidMarker) {
+    if (value === undefined || value === null)
+        return [];
+    if (!Array.isArray(value))
+        return [invalidMarker];
+    const strings = value.filter((entry) => typeof entry === 'string').map((entry) => entry.trim()).filter(Boolean);
+    if (strings.length !== value.length)
+        strings.push(invalidMarker);
+    return [...new Set(strings)];
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
 async function checkHardBlocker(root, missionId) {
     if (!missionId)
         return { hardBlocked: false, file: null, reason: null, evidence: [] };
@@ -131,16 +164,19 @@ export async function checkStopGate(input) {
             feedback: `Stop blocked: no gate file found. Checked paths: ${resolution.checked_paths.join(', ')}`,
         };
     }
+    const notApplicable = normalizedGate.status === 'not_applicable';
     const missingFields = [];
-    if (normalizedGate.status !== 'passed')
+    if (!notApplicable && normalizedGate.status !== 'passed')
         missingFields.push('status');
-    if (normalizedGate.passed !== true)
+    if (!notApplicable && normalizedGate.passed !== true)
         missingFields.push('passed');
+    if (notApplicable && !String(normalizedGate.reason || '').trim())
+        missingFields.push('not_applicable_reason');
     if (normalizedGate.blockers.length > 0)
         missingFields.push('blockers');
     if (normalizedGate.missing_fields.length > 0)
         missingFields.push(...normalizedGate.missing_fields.map((field) => `missing_fields:${field}`));
-    const bugfixMission = await missionHasBugfixWork(root, missionId, normalizedGate);
+    const bugfixMission = !notApplicable && await missionHasBugfixWork(root, missionId, normalizedGate);
     if (bugfixMission && normalizedGate.evidence.regression_test_added !== true)
         missingFields.push('regression_test_added');
     if (bugfixMission && normalizedGate.evidence.regression_test_failed_before_fix !== true)
@@ -149,8 +185,7 @@ export async function checkStopGate(input) {
         missingFields.push('coverage_required_but_not_passed');
     if ((normalizedGate.evidence.uncovered_required_count ?? 0) > 0)
         missingFields.push(`work_order_uncovered_count:${normalizedGate.evidence.uncovered_required_count}`);
-    if (normalizedGate.status === 'passed'
-        && normalizedGate.passed === true
+    if ((normalizedGate.status === 'passed' && normalizedGate.passed === true || notApplicable)
         && normalizedGate.blockers.length === 0
         && normalizedGate.missing_fields.length === 0
         && missingFields.length === 0) {
@@ -167,7 +202,7 @@ export async function checkStopGate(input) {
             selected_gate_mtime: statInfo.mtime,
             current_state_path: resolution.current_state_path,
             current_state_mission_id: resolution.current_state_mission_id,
-            reason: 'gate_passed',
+            reason: notApplicable ? 'gate_not_applicable' : 'gate_passed',
             missing_fields: [],
             blockers: [],
         };
@@ -181,7 +216,9 @@ export async function checkStopGate(input) {
             gate_path: resolution.gate_path,
             normalized_gate: normalizedGate,
             diagnostics,
-            feedback: `Stop allowed: gate passed at ${resolution.gate_path}`,
+            feedback: notApplicable
+                ? `Stop allowed: active gate is not applicable at ${resolution.gate_path}`
+                : `Stop allowed: gate passed at ${resolution.gate_path}`,
         };
     }
     // Gate not passed

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

@@ -0,0 +1,215 @@
+import { MANAGED_OFFICIAL_SUBAGENT_ROLES } from '../managed-assets/managed-assets-manifest.js';
+export const DEFAULT_AUTOMATIC_SUBAGENT_COUNT = 1;
+export const MAX_AUTOMATIC_SUBAGENT_COUNT = 3;
+export const MAX_AUTOMATIC_REVIEWER_COUNT = 2;
+export function officialSubagentRoleCatalog() {
+    return MANAGED_OFFICIAL_SUBAGENT_ROLES.map((role) => ({
+        name: role.codex_name,
+        description: role.description,
+        model: role.model,
+        model_reasoning_effort: role.model_reasoning_effort,
+        sandbox_mode: role.sandbox || 'inherit'
+    }));
+}
+export function officialSubagentRolePlan() {
+    return Object.fromEntries(officialSubagentRoleCatalog().map(({ name, ...config }) => [name, config]));
+}
+export function recommendOfficialSubagentRoles(input = {}) {
+    const text = normalizeText([
+        input.title,
+        input.description,
+        input.role,
+        input.expectedOutput,
+        ...(input.paths || [])
+    ]);
+    const limit = clamp(input.limit ?? MAX_AUTOMATIC_SUBAGENT_COUNT, 1, MAX_AUTOMATIC_SUBAGENT_COUNT);
+    const scored = MANAGED_OFFICIAL_SUBAGENT_ROLES
+        .map((role, index) => ({ role, index, score: roleScore(role, text, input) }))
+        .filter((row) => input.readOnly !== true || row.role.sandbox === 'read-only');
+    const solSpecialistMatched = scored.some((row) => row.score > 0
+        && row.role.model === 'gpt-5.6-sol'
+        && !['worker', 'expert'].includes(row.role.codex_name));
+    const ranked = scored
+        .filter((row) => !(solSpecialistMatched && row.role.codex_name === 'worker'))
+        .filter((row) => row.score > 0)
+        .sort((left, right) => right.score - left.score || left.index - right.index)
+        .map((row) => row.role.codex_name);
+    if (ranked.length)
+        return unique(ranked).slice(0, limit);
+    if (input.readOnly === true)
+        return ['expert'];
+    if (looksClearBounded(text))
+        return ['worker'];
+    return [input.requiresWrite === true ? 'implementation_specialist' : 'expert'];
+}
+export function selectOfficialSubagentRole(input = {}) {
+    return recommendOfficialSubagentRoles({ ...input, limit: 1 })[0] || 'expert';
+}
+export function officialSubagentFanoutPolicy(input = {}) {
+    const explicit = input.requestedExplicit === true;
+    const explicitRequested = Number.isFinite(Number(input.requestedSubagents))
+        ? Math.max(1, Math.floor(Number(input.requestedSubagents)))
+        : DEFAULT_AUTOMATIC_SUBAGENT_COUNT;
+    const automatic = automaticSubagentFanout({
+        ...(input.taskProfile === undefined ? {} : { taskProfile: input.taskProfile }),
+        ...(input.goal === undefined ? {} : { goal: input.goal }),
+        ...(input.suggestedRoles === undefined ? {} : { suggestedRoles: input.suggestedRoles })
+    });
+    const requested = explicit ? explicitRequested : automatic.count;
+    const automaticReviewerCeiling = automatic.criticalMultiDomain
+        ? MAX_AUTOMATIC_SUBAGENT_COUNT
+        : MAX_AUTOMATIC_REVIEWER_COUNT;
+    return {
+        mode: explicit ? 'explicit_operator_count' : 'parent_owned_risk_based',
+        requested_subagents: requested,
+        default_subagents: DEFAULT_AUTOMATIC_SUBAGENT_COUNT,
+        automatic_selected: explicit ? null : automatic.count,
+        automatic_ceiling: automatic.ceiling,
+        automatic_reviewer_ceiling: automaticReviewerCeiling,
+        selection_reason: explicit ? 'explicit_operator_count_preserved' : automatic.reason,
+        risk_domains: automatic.riskDomains,
+        critical_multi_domain: automatic.criticalMultiDomain,
+        requires_independent_non_overlapping_slices: true,
+        suggested_agents: unique((input.suggestedRoles || []).map(String)).slice(0, MAX_AUTOMATIC_SUBAGENT_COUNT)
+    };
+}
+function automaticSubagentFanout(input) {
+    const text = normalizeText([input.goal]);
+    const riskDomains = unique([
+        ...riskDomainsFromText(text),
+        ...riskDomainsFromRoles(input.suggestedRoles || [])
+    ]);
+    const parallel = input.taskProfile === 'parallel-read' || input.taskProfile === 'parallel-write';
+    const highRisk = input.taskProfile === 'high-risk';
+    const critical = CRITICAL_RISK_RE.test(text);
+    const criticalMultiDomain = highRisk && critical && riskDomains.length >= 3;
+    if (criticalMultiDomain) {
+        return {
+            count: MAX_AUTOMATIC_SUBAGENT_COUNT,
+            ceiling: MAX_AUTOMATIC_SUBAGENT_COUNT,
+            reason: 'critical_multi_domain_risk',
+            riskDomains,
+            criticalMultiDomain: true
+        };
+    }
+    if (parallel) {
+        return {
+            count: 2,
+            ceiling: 2,
+            reason: 'explicit_parallel_or_independent_slices',
+            riskDomains,
+            criticalMultiDomain: false
+        };
+    }
+    if (highRisk && riskDomains.length >= 2) {
+        return {
+            count: 2,
+            ceiling: 2,
+            reason: 'independent_multi_domain_risk',
+            riskDomains,
+            criticalMultiDomain: false
+        };
+    }
+    return {
+        count: DEFAULT_AUTOMATIC_SUBAGENT_COUNT,
+        ceiling: DEFAULT_AUTOMATIC_SUBAGENT_COUNT,
+        reason: 'single_bounded_or_single_domain_task',
+        riskDomains,
+        criticalMultiDomain: false
+    };
+}
+function riskDomainsFromText(text) {
+    const domains = [];
+    for (const [domain, pattern] of RISK_DOMAIN_PATTERNS) {
+        if (pattern.test(text))
+            domains.push(domain);
+    }
+    return domains;
+}
+function riskDomainsFromRoles(roles) {
+    return roles
+        .map((role) => ROLE_RISK_DOMAINS[String(role || '').trim()] || null)
+        .filter((domain) => Boolean(domain));
+}
+function roleScore(role, text, input) {
+    const semanticScore = [...role.selection_keywords, ...(ROLE_LANGUAGE_HINTS[role.codex_name] || [])]
+        .reduce((total, keyword) => total + keywordScore(text, keyword), 0);
+    if (semanticScore <= 0)
+        return 0;
+    let score = semanticScore;
+    if (input.readOnly === true)
+        score += role.sandbox === 'read-only' ? 2 : role.sandbox ? -3 : 0;
+    if (input.requiresWrite === true)
+        score += role.sandbox === 'read-only' ? -3 : role.sandbox === 'workspace-write' ? 2 : 1;
+    if (role.codex_name === 'worker' && !looksClearBounded(text))
+        score -= 4;
+    if (role.codex_name === 'expert')
+        score -= 1;
+    return score;
+}
+function keywordScore(text, keyword) {
+    const normalized = normalizeText([keyword]);
+    if (!normalized)
+        return 0;
+    const matched = /^[a-z0-9]+$/i.test(normalized)
+        ? new RegExp(`(?:^|\\b)${escapeRegExp(normalized)}(?:\\b|$)`, 'i').test(text)
+        : text.includes(normalized);
+    if (!matched)
+        return 0;
+    return normalized.includes(' ') ? 4 : 3;
+}
+function looksClearBounded(text) {
+    return /\b(bounded|mechanical|repeatable|exact|single[- ](?:file|step|change)|rename|format|copy|fixture)\b|정해진|명확한|기계적|반복적|단일\s*파일/i.test(text);
+}
+function normalizeText(values) {
+    return values
+        .map((value) => String(value || '').normalize('NFKC').toLowerCase())
+        .join(' ')
+        .replace(/[_/\\.-]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function unique(values) {
+    return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))];
+}
+function clamp(value, minimum, maximum) {
+    return Math.max(minimum, Math.min(maximum, Math.floor(Number(value) || minimum)));
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+const ROLE_LANGUAGE_HINTS = {
+    worker: ['기계적', '반복적', '단순 변경', '정확한 변경'],
+    implementation_specialist: ['구현', '기능 추가', '핵심 로직', '백엔드', '복잡한 변경'],
+    expert: ['모호', '전략', '판단', '트레이드오프'],
+    explorer: ['탐색', '찾아', '추적', '인벤토리', '구조 파악'],
+    debugger: ['디버깅', '원인', '실패', '재현', '회귀'],
+    test_engineer: ['테스트', '회귀 테스트', '검증', '픽스처', '커버리지'],
+    ui_implementer: ['화면', '터미널', '젤리', '패널', '팬', '레이아웃', '사용성'],
+    architecture_reviewer: ['아키텍처', '설계', '수명주기', '결합도', '리팩터'],
+    security_reviewer: ['보안', '권한', '인증', '비밀', '신뢰 경계'],
+    database_reviewer: ['데이터베이스', '디비', '마이그레이션', '롤백', '스키마'],
+    research_synthesizer: ['연구', '논문', '가설', '종합', '새로움'],
+    research_reviewer: ['논문 검토', '적대적 평가', '방법론', '재현성', '반증'],
+    release_reviewer: ['배포', '릴리스', '출시', '퍼블리시', '버전'],
+    docs_maintainer: ['문서', '리드미', '변경로그', '마이그레이션 가이드'],
+    integration_reviewer: ['통합', '병합', '리베이스', '호환성', '엔드투엔드'],
+    performance_analyst: ['성능', '지연', '벤치마크', '동시성', '토큰', '메모리']
+};
+const CRITICAL_RISK_RE = /\b(?:critical|catastrophic|production|data loss|security incident|breaking release)\b|치명|중대|운영|데이터\s*손실|보안\s*사고/i;
+const RISK_DOMAIN_PATTERNS = [
+    ['database', /\b(?:database|db|sql|postgres|supabase|migration|rls)\b|데이터베이스|디비|마이그레이션/i],
+    ['security', /\b(?:security|permission|auth|authentication|secret|trust boundary)\b|보안|권한|인증|비밀|신뢰\s*경계/i],
+    ['release', /\b(?:release|publish|deploy|distribution|package registry|production rollout)\b|릴리스|배포|출시|퍼블리시/i],
+    ['payment', /\b(?:payment|billing|checkout|transaction)\b|결제|청구|트랜잭션/i],
+    ['performance', /\b(?:performance|latency|throughput|concurrency|resource usage)\b|성능|지연|처리량|동시성/i],
+    ['integration', /\b(?:integration|compatibility|cross-module|end-to-end)\b|통합|호환성|엔드투엔드/i]
+];
+const ROLE_RISK_DOMAINS = {
+    security_reviewer: 'security',
+    database_reviewer: 'database',
+    release_reviewer: 'release',
+    performance_analyst: 'performance',
+    integration_reviewer: 'integration'
+};
+//# sourceMappingURL=agent-catalog.js.map

package/dist/core/subagents/model-policy.js

@@ -0,0 +1,118 @@
+export const NARUTO_PARENT_MODEL = 'gpt-5.6-sol';
+export const NARUTO_PARENT_EFFORT = 'max';
+export const DEFAULT_SUBAGENT_MODEL = 'gpt-5.6-luna';
+export const THINKING_SUBAGENT_MODEL = 'gpt-5.6-sol';
+export const SUBAGENT_EFFORT = 'max';
+const SOL_TASK_RE = new RegExp([
+    '\\bui\\b',
+    '\\bux\\b',
+    '\\bgui\\b',
+    'frontend',
+    'visual',
+    'review',
+    'audit',
+    'debug',
+    'diagnos',
+    'investigat',
+    '\\bwhy\\b',
+    '\\bfail(?:ed|ure|ing)?\\b',
+    'root[- ]?cause',
+    'strategy',
+    '\\bplan\\b',
+    'planning',
+    'product',
+    'architecture',
+    'architect',
+    'design',
+    'refactor',
+    'integrat',
+    'conflict',
+    'security',
+    '\\bauth(?:entication|orization)?\\b',
+    '\\bsafety\\b',
+    'database',
+    '\\bdb\\b',
+    'migration',
+    'release',
+    'publish',
+    'deploy',
+    'tests?[-_ ]?(?:fail|failure|debug|diagnos|root[- ]?cause)',
+    'failing tests?',
+    'flaky',
+    'ambiguous',
+    'ambiguity',
+    'trade[- ]?off',
+    'quality',
+    'judg',
+    'assessment',
+    '\\bexpert\\b',
+    '\\brisk\\b',
+    '사용성',
+    '화면',
+    '유아이',
+    '유엑스',
+    '프론트엔드',
+    '리뷰',
+    '검토',
+    '디버깅',
+    '진단',
+    '원인',
+    '전략',
+    '기획',
+    '계획',
+    '설계',
+    '아키텍처',
+    '리팩터',
+    '통합',
+    '충돌',
+    '보안',
+    '안전',
+    '데이터베이스',
+    '마이그레이션',
+    '배포',
+    '릴리즈',
+    '출시',
+    '모호',
+    '트레이드오프',
+    '품질',
+    '판정',
+    '위험'
+].join('|'), 'i');
+const CLEAR_BOUNDED_TASK_RE = new RegExp([
+    '\\b(?:clear|bounded|exact|specified)\\b[^\n]{0,48}\\b(?:task|change|step|scope|fixture|file|implementation|rename|copy|format|inventory|extract|list|check)\\b',
+    '\\b(?:mechanical|repeatable)\\b',
+    '\\bstructured[- ]?(?:extract|extraction|output|inventory|list)\\b',
+    'code_modification',
+    'test_execution',
+    'single[- ]?(?:file|step|check|change)',
+    '(?:정해진|명확한?|단순한?|반복적?|기계적)[^\n]{0,32}(?:작업|변경|단계|파일|목록|추출|이름\\s*변경)'
+].join('|'), 'i');
+export function decideSubagentModel(input = {}) {
+    const text = [
+        input.title,
+        input.description,
+        input.role,
+        input.expectedOutput
+    ].filter(Boolean).join(' ');
+    const useSol = input.requiresJudgment === true
+        || SOL_TASK_RE.test(text)
+        || !CLEAR_BOUNDED_TASK_RE.test(text);
+    if (useSol) {
+        return {
+            kind: 'expert',
+            model: THINKING_SUBAGENT_MODEL,
+            modelReasoningEffort: SUBAGENT_EFFORT,
+            reason: 'reasoning_sensitive_task'
+        };
+    }
+    return {
+        kind: 'worker',
+        model: DEFAULT_SUBAGENT_MODEL,
+        modelReasoningEffort: SUBAGENT_EFFORT,
+        reason: 'clear_bounded_repeatable_task'
+    };
+}
+export function isReasoningSensitiveSubagentTask(input = {}) {
+    return decideSubagentModel(input).kind === 'expert';
+}
+//# sourceMappingURL=model-policy.js.map

package/dist/core/subagents/naruto-help-contract.js

@@ -0,0 +1,40 @@
+import { NARUTO_PARENT_EFFORT, NARUTO_PARENT_MODEL } from './model-policy.js';
+import { DEFAULT_NARUTO_REQUESTED_SUBAGENTS } from './thread-budget.js';
+import { MAX_AUTOMATIC_REVIEWER_COUNT, MAX_AUTOMATIC_SUBAGENT_COUNT, officialSubagentRolePlan } from './agent-catalog.js';
+export const NARUTO_HELP_SCHEMA = 'sks.naruto-subagent-workflow.v1';
+export function buildNarutoHelpResult() {
+    return {
+        schema: NARUTO_HELP_SCHEMA,
+        ok: true,
+        action: 'help',
+        workflow: 'official_codex_subagent',
+        description: '$Naruto is the SKS alias for the Codex official subagent workflow.',
+        usage: [
+            'sks naruto run "<task>" [--agents N] [--max-threads N] [--json]',
+            'sks naruto status [latest|M-...] [--json]',
+            'sks naruto subagents [latest|M-...] [--json]',
+            'sks naruto proof [latest|M-...] [--json]'
+        ],
+        commands: ['help', 'status', 'subagents', 'proof', 'run'],
+        default_requested_subagents: DEFAULT_NARUTO_REQUESTED_SUBAGENTS,
+        scaling_policy: 'one_safe_direct_child_by_default_parent_owned_risk_based_expansion',
+        automatic_subagent_ceiling: MAX_AUTOMATIC_SUBAGENT_COUNT,
+        automatic_reviewer_ceiling: MAX_AUTOMATIC_REVIEWER_COUNT,
+        critical_multi_domain_reviewer_ceiling: MAX_AUTOMATIC_SUBAGENT_COUNT,
+        max_depth: 1,
+        triwiki_context: 'bounded_attention_use_first_with_on_demand_hydration',
+        completion_evidence: {
+            lifecycle_events: ['SubagentStart', 'SubagentStop'],
+            stop_is_success_evidence: false,
+            structured_parent_summary: 'subagent-parent-summary.json'
+        },
+        deprecated_aliases: {
+            '--clones N': '--agents N',
+            workers: 'subagents'
+        },
+        legacy_process_runtime_available: false,
+        parent: { model: NARUTO_PARENT_MODEL, model_reasoning_effort: NARUTO_PARENT_EFFORT },
+        agents: officialSubagentRolePlan()
+    };
+}
+//# sourceMappingURL=naruto-help-contract.js.map