sneakoscope 10.2.0 → 10.3.0

package/dist/core/decisions/recovery.js

@@ -0,0 +1,39 @@
+export const RECOVERY_CAPABILITY = Object.freeze({
+    supported: false,
+    reason: 'unsupported_no_sks_handler',
+    evidence: [
+        'src/core/subagents/official-subagent-preparation.ts::recoverOfficialSubagentPreparationTransaction is deterministic crash recovery, not an ambiguous-failure Choice consumer',
+        'src/core/subagents/official-subagent-runner.ts OAuth hint is a deterministic auth/port-conflict path',
+        'src/core/triwiki/context-graph/store journal recovery is deterministic store repair',
+        'Codex spawn_agent/send_input remain native-host-owned; a saved plan is not dispatch proof'
+    ]
+});
+const testHandlers = new Map();
+export function listProductionRecoveryCandidates() {
+    return [];
+}
+export function setRecoveryTestHandler(actionId, handler) {
+    if (process.env.SKS_JEV_DECISION_TEST_OVERRIDES !== '1') {
+        throw new Error('recovery_test_handler_requires_test_overrides');
+    }
+    if (!handler) {
+        testHandlers.delete(actionId);
+        return;
+    }
+    testHandlers.set(actionId, handler);
+}
+export async function applyRecoveryEffect(input) {
+    if (process.env.SKS_JEV_DECISION_TEST_OVERRIDES !== '1') {
+        return { ok: false, reason: 'capability_unavailable' };
+    }
+    const candidate = input.candidates.find((row) => row.id === input.actionId);
+    if (!candidate)
+        return { ok: false, reason: 'invalid_response' };
+    if (!candidate.authorized)
+        return { ok: false, reason: 'unauthorized' };
+    const handler = testHandlers.get(candidate.handlerId);
+    if (!handler)
+        return { ok: false, reason: 'capability_unavailable' };
+    const result = await handler({ actionId: candidate.id, diagnostic: input.diagnostic, candidate });
+    return { ok: true, actionId: result.actionId, consumptionEvidence: result.consumptionEvidence };
+}

package/dist/core/decisions/routing.js

@@ -0,0 +1,58 @@
+import { sealedRoutingModel } from './types.js';
+const ROLE_ID = /^[a-z][a-z0-9_]{0,40}$/;
+export const MAX_JEV_ROUTING_ROLES = 8;
+export function buildRoutingCandidates(input) {
+    const out = [];
+    const seen = new Set();
+    for (const role of input.roles) {
+        const name = role.name.trim();
+        if (!role.dynamic || !ROLE_ID.test(name) || seen.has(name))
+            continue;
+        seen.add(name);
+        out.push({ id: name, summary: role.summary.trim().slice(0, 240) });
+        if (out.length >= MAX_JEV_ROUTING_ROLES)
+            break;
+    }
+    return out;
+}
+export function applySealedRouting(agents, selected) {
+    if (!selected || !agents)
+        return { ...(agents || {}) };
+    const next = { ...agents };
+    for (const [name, effort] of Object.entries(selected.efforts)) {
+        const model = selected.models[name];
+        const sealed = model ? sealedRoutingModel(model) : null;
+        if (!sealed || sealed.effort !== effort)
+            continue;
+        const row = next[name];
+        if (!row || row.routing_dynamic !== true || row.routed_model_policy === 'user_role_model_preference')
+            continue;
+        next[name] = {
+            ...row,
+            routed_model: sealed.id,
+            routed_model_reasoning_effort: effort,
+            routed_model_policy: 'jev_sealed_routing',
+            jev_routing_lane: selected.id
+        };
+    }
+    return next;
+}
+export function assembleRoutingSelection(effects) {
+    const models = {};
+    const efforts = {};
+    for (const effect of effects) {
+        const sealed = sealedRoutingModel(effect.model);
+        if (!sealed || !ROLE_ID.test(effect.roleId))
+            continue;
+        models[effect.roleId] = sealed.id;
+        efforts[effect.roleId] = sealed.effort;
+    }
+    if (Object.keys(models).length === 0)
+        return null;
+    return {
+        id: 'jev_role_fanout',
+        summary: 'Jev chose a sealed model for each dynamic Naruto role.',
+        models,
+        efforts
+    };
+}

package/dist/core/decisions/state.js

@@ -0,0 +1,173 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { runProcess, sha256 } from '../fsx.js';
+import { inspectConfinedPath } from '../managed-path-safety.js';
+import { redactSecrets } from '../secret-redaction.js';
+import { DESIGN_DEFAULTS, POLICY_REVISION } from './types.js';
+export const MAX_EXCERPT_CHARS = 800;
+const SECRET_PATTERNS = [
+    /\b(?:sk|rk|pk)-[A-Za-z0-9_-]{16,}\b/g,
+    /\bAKIA[0-9A-Z]{16}\b/g,
+    /\bgh[pousr]_[A-Za-z0-9]{20,}\b/g,
+    /\bxox[abpr]-[A-Za-z0-9-]{10,}\b/g,
+    /\bhf_[A-Za-z0-9]{20,}\b/g,
+    /\bBearer\s+[A-Za-z0-9._~+/=-]{16,}/gi,
+    /-----BEGIN [A-Z ]+PRIVATE KEY-----[\s\S]*?-----END [A-Z ]+PRIVATE KEY-----/g
+];
+export function redactDecisionText(text, maxChars = 2_000) {
+    let out = String(text || '').replace(/\r\n?/g, '\n').replace(/[ \t]+/g, ' ').replace(/\n{3,}/g, '\n\n').trim();
+    out = String(redactSecrets(out));
+    for (const pattern of SECRET_PATTERNS)
+        out = out.replace(pattern, '[redacted]');
+    if (out.length > maxChars)
+        out = `${out.slice(0, maxChars - 12).trimEnd()} [truncated]`;
+    return out;
+}
+export function stableDigest(value) {
+    return sha256(canonicalJson(value));
+}
+export function canonicalJson(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map((entry) => canonicalJson(entry)).join(',')}]`;
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(',')}}`;
+}
+export async function sourceSnapshotDigest(root) {
+    const cwd = path.resolve(root);
+    const head = await gitText(cwd, ['rev-parse', 'HEAD']);
+    const porcelain = await gitText(cwd, ['status', '--porcelain']);
+    const dirty = porcelain.split('\n').map((line) => line.trim()).filter(Boolean);
+    const dirtyHashes = [];
+    for (const line of dirty.slice(0, 64)) {
+        const relative = line.replace(/^[ MADRCU?!]{1,2}\s+/, '').split(' -> ').pop() || '';
+        if (!relative || relative.includes('..'))
+            continue;
+        const file = path.join(cwd, relative);
+        const inspected = await inspectConfinedPath(cwd, file).catch(() => null);
+        if (!inspected?.exists || inspected.leafSymlink || !inspected.stat?.isFile()) {
+            dirtyHashes.push(`${relative}:unreadable`);
+            continue;
+        }
+        const bytes = await fsp.readFile(file).catch(() => Buffer.alloc(0));
+        dirtyHashes.push(`${relative}:${sha256(bytes)}`);
+    }
+    return stableDigest({ head, dirty, dirtyHashes });
+}
+export async function graphFileDigest(root) {
+    const file = path.join(path.resolve(root), '.sneakoscope', 'wiki', 'context-graph.json');
+    const inspected = await inspectConfinedPath(path.resolve(root), file).catch(() => null);
+    if (!inspected?.exists || inspected.leafSymlink || !inspected.stat?.isFile())
+        return null;
+    const bytes = await fsp.readFile(file);
+    return sha256(bytes);
+}
+export function buildDecisionBinding(input) {
+    return {
+        projectId: input.projectId,
+        workflowRunId: input.workflowRunId,
+        workflowRevision: input.workflowRevision,
+        sourceDigest: input.sourceDigest,
+        graphDigest: input.graphDigest,
+        candidateDigest: stableDigest(input.candidates),
+        questionDigest: stableDigest(input.questions),
+        policyRevision: POLICY_REVISION,
+        requestedModel: input.requestedModel || DESIGN_DEFAULTS.model
+    };
+}
+export async function hydrateContextCandidates(root, attention, changedPaths = []) {
+    if (!attention?.available)
+        return [];
+    const pinnedPaths = new Set(changedPaths.map((entry) => normalizeRel(entry)));
+    const out = [];
+    for (const anchor of attention.anchors) {
+        const candidate = await hydrateAnchor(root, anchor, pinnedPaths);
+        if (candidate)
+            out.push(candidate);
+    }
+    return out;
+}
+export function applyOptionalContextSelection(attention, candidates, keepIds) {
+    const keep = new Set(keepIds);
+    for (const candidate of candidates) {
+        if (candidate.pinned)
+            keep.add(candidate.id);
+    }
+    const selected = attention.anchors.filter((anchor) => {
+        const candidate = candidates.find((row) => row.id === anchor.id);
+        if (!candidate)
+            return true;
+        return keep.has(anchor.id);
+    }).map((anchor) => attachExcerpt(anchor, candidates.find((row) => row.id === anchor.id)));
+    return {
+        ...attention,
+        anchors: selected,
+        token_cost: selected.reduce((sum, anchor) => sum + anchor.token_cost, 0)
+    };
+}
+async function hydrateAnchor(root, anchor, pinnedPaths) {
+    const provenance = anchor.provenance[0];
+    if (!provenance?.path || !provenance.hash) {
+        return {
+            id: anchor.id,
+            sourcePath: '',
+            sourceHash: anchor.source_hash || '',
+            excerpt: '',
+            pinned: true,
+            fresh: false,
+            reproducible: false
+        };
+    }
+    const relative = normalizeRel(provenance.path);
+    const excerpt = await readExcerpt(root, relative, provenance.line);
+    const named = pinnedPaths.has(relative);
+    const fresh = anchor.freshness === 'fresh';
+    const reproducible = Boolean(excerpt && provenance.hash);
+    const optional = !named && fresh && reproducible && Boolean(excerpt);
+    return {
+        id: anchor.id,
+        sourcePath: relative,
+        sourceHash: provenance.hash,
+        excerpt,
+        pinned: !optional,
+        fresh,
+        reproducible
+    };
+}
+async function readExcerpt(root, relative, line) {
+    const cwd = path.resolve(root);
+    const file = path.join(cwd, relative);
+    const inspected = await inspectConfinedPath(cwd, file).catch(() => null);
+    if (!inspected?.exists || inspected.leafSymlink || !inspected.stat?.isFile())
+        return '';
+    if (inspected.stat.size > 256 * 1024)
+        return '';
+    const raw = await fsp.readFile(file, 'utf8').catch(() => '');
+    if (!raw)
+        return '';
+    const lines = raw.split('\n');
+    const focus = Number.isInteger(line) && (line || 0) > 0 ? Math.min(lines.length, line || 1) : 1;
+    const start = Math.max(0, focus - 8);
+    const slice = lines.slice(start, start + 24).join('\n');
+    return redactDecisionText(slice, MAX_EXCERPT_CHARS);
+}
+function attachExcerpt(anchor, candidate) {
+    if (!candidate?.excerpt)
+        return anchor;
+    return {
+        ...anchor,
+        excerpt: candidate.excerpt,
+        source_path: candidate.sourcePath,
+        optional: !candidate.pinned
+    };
+}
+function normalizeRel(value) {
+    return value.replace(/\\/g, '/').replace(/^\.\//, '').trim();
+}
+async function gitText(cwd, args) {
+    const result = await runProcess('git', args, { cwd, timeoutMs: 2_000, envMode: 'merge' }).catch(() => null);
+    if (!result || result.code !== 0)
+        return '';
+    return String(result.stdout || '').trim();
+}

package/dist/core/decisions/types.js

@@ -0,0 +1,69 @@
+export const SEALED_ROUTING_MODELS = Object.freeze([
+    Object.freeze({
+        id: 'gpt-5.6-luna',
+        effort: 'low',
+        summary: 'Fastest sealed model. Mechanical edits, renames, formatting, and other one-step changes.'
+    }),
+    Object.freeze({
+        id: 'gpt-5.6-sol',
+        effort: 'low',
+        summary: 'Fast sealed model. Simple coding whose result is already specified.'
+    }),
+    Object.freeze({
+        id: 'gpt-5.6-terra',
+        effort: 'medium',
+        summary: 'Context and tools. Search, multi-file reading, and broad exploration.'
+    }),
+    Object.freeze({
+        id: 'gpt-6-astra',
+        effort: 'max',
+        summary: 'Escalate. Judgment, architecture, ambiguity, security, or high-stakes work.'
+    })
+]);
+export const ROUTING_DIFFICULTY_RUBRIC = Object.freeze([
+    'Mechanical one-step work: rename, format, copy, or a single exact edit.',
+    'Simple coding whose result is already specified.',
+    'Broad context, search, or tool use across more than one file.',
+    'Judgment, architecture, ambiguity, security, or other high-stakes work.'
+]);
+export const ROUTING_RISK_NOUL_MIN = 0.70;
+export function sealedRoutingModel(model) {
+    const match = SEALED_ROUTING_MODELS.find((row) => row.id === model);
+    return match ? { id: match.id, effort: match.effort } : null;
+}
+export const DESIGN_DEFAULTS = Object.freeze({
+    mode: 'off',
+    model: 'typesafe/jev-1.13',
+    endpoint: 'https://openrouter.ai/api/alpha/decisions',
+    deadlineMs: 1500,
+    retries: 0,
+    maxInFlight: 2,
+    maxQueued: 0,
+    maxQuestions: 32,
+    maxRequestBytes: 24 * 1024,
+    maxResponseBytes: 256 * 1024,
+    memoEntries: 128,
+    circuitFailures: 3,
+    circuitOpenMs: 30000
+});
+export const POLICY_REVISION = 'sks.jev-policy.v2';
+export const QUESTION_REVISION = 'sks.jev-questions.v1';
+export const RECEIPT_SCHEMA = 'sks.jev-decision.v1';
+export const CHOICE_MIN_PROBABILITY = 0.85;
+export const CHOICE_MIN_CONFIDENCE = 0.70;
+export const CONTEXT_DROP_NOUL_MAX = 0.10;
+export const DISTRIBUTION_SUM_TOLERANCE = 1e-3;
+export const KEEP_BASELINE_CHOICE = 'keep_baseline';
+export const NEEDS_EVIDENCE_CHOICE = 'needs_evidence';
+export const CONTEXT_RELEVANCE_RUBRIC = Object.freeze([
+    'No information needed for the stated task.',
+    'Indirect background, with no task-specific constraint or evidence.',
+    'Useful supporting evidence for at least one task requirement.',
+    'Direct evidence needed to implement or verify a task requirement.'
+]);
+export const UNKNOWN_USAGE = Object.freeze({
+    inputTokens: null,
+    outputTokens: null,
+    reportedCost: null,
+    evidence: 'unknown'
+});

package/dist/core/feature-fixtures.js

@@ -89,6 +89,7 @@ const FIXTURES = Object.freeze({
     'cli-bench': fixture('execute_and_validate_artifacts', 'sks bench core --tier npx-one-shot --json --iterations 1', ['.sneakoscope/reports/performance/core-bench.json'], 'pass'),
     'cli-code-structure': fixture('execute', 'sks code-structure scan --json', [], 'pass', { timeout_ms: 180000 }),
     'cli-rust': fixture('execute', 'sks rust smoke --json', [], 'pass'),
+    'cli-decision': fixture('execute', 'sks decision status --json', [], 'pass'),
     'cli-skill-dream': fixture('execute', 'sks skill-dream status --json', [], 'pass'),
     'cli-gc': fixture('execute', 'sks gc --dry-run --json', [], 'pass'),
     'cli-cleanup': fixture('execute', 'sks cleanup plan --json', [], 'pass', {

package/dist/core/feature-registry.js

@@ -541,6 +541,7 @@ const SAFE_EXECUTABLE_FIXTURE_ARGS = Object.freeze({
     'cli-bench': ['bench', 'core', '--tier', 'npx-one-shot', '--json', '--iterations', '1'],
     'cli-code-structure': ['code-structure', 'scan', '--json'],
     'cli-rust': ['rust', 'smoke', '--json'],
+    'cli-decision': ['decision', 'status', '--json'],
     'cli-skill-dream': ['skill-dream', 'status', '--json'],
     'cli-gc': ['gc', '--dry-run', '--json'],
     'cli-cleanup': ['cleanup', 'plan', '--json'],

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

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { readJson } from '../fsx.js';
 import { managedOfficialSubagentRoleByName } from '../managed-assets/managed-assets-manifest.js';
-import { ASTRA_SUBAGENT_MODEL } from '../subagents/model-policy.js';
+import { ASTRA_SUBAGENT_MODEL, NARUTO_LUNA_MODEL, NARUTO_SOL_MODEL, NARUTO_TERRA_MODEL } from '../subagents/model-policy.js';
 export async function sealedSubagentRoutingContext(artifactDir, payload = {}) {
     const plan = await readJson(path.join(artifactDir, 'subagent-plan.json'), null).catch(() => null);
     if (!plan || plan.workflow !== 'official_codex_subagent')
@@ -12,9 +12,11 @@ export async function sealedSubagentRoutingContext(artifactDir, payload = {}) {
     const role = agentName ? managedOfficialSubagentRoleByName(agentName) : null;
     if (!agentName)
         return '';
-    const model = ASTRA_SUBAGENT_MODEL;
+    const narutoPlan = plan.mode === 'naruto' || plan.route === '$Naruto';
     const plannedModel = String(planned?.routed_model || planned?.model || '').trim();
-    const effort = String((plannedModel === ASTRA_SUBAGENT_MODEL
+    const sealedModels = new Set([ASTRA_SUBAGENT_MODEL, NARUTO_LUNA_MODEL, NARUTO_SOL_MODEL, NARUTO_TERRA_MODEL]);
+    const model = narutoPlan && sealedModels.has(plannedModel) ? plannedModel : ASTRA_SUBAGENT_MODEL;
+    const effort = String((model === plannedModel
         ? planned?.routed_model_reasoning_effort || planned?.model_reasoning_effort
         : null) || role?.model_reasoning_effort || 'medium').trim();
     return [

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

@@ -1,12 +1,18 @@
-import { ASTRA_SUBAGENT_MODEL } from '../subagents/model-policy.js';
+import { ASTRA_SUBAGENT_MODEL, NARUTO_LUNA_MODEL, NARUTO_SOL_MODEL, NARUTO_TERRA_MODEL } from '../subagents/model-policy.js';
 const SPAWN_TOOLS = new Set(['spawn_agent', 'collaboration.spawn_agent', 'functions.spawn_agent']);
+const SEALED_CHILD_MODELS = new Set([
+    ASTRA_SUBAGENT_MODEL,
+    NARUTO_LUNA_MODEL,
+    NARUTO_SOL_MODEL,
+    NARUTO_TERRA_MODEL
+]);
 export function subagentSpawnPolicyBlockReason(payload = {}) {
     const name = String(payload.tool_name || payload.toolName || payload.tool?.name || '');
     if (!SPAWN_TOOLS.has(name))
         return null;
     const input = payload.tool_input || payload.toolInput || payload.tool?.input || {};
-    if (input.model !== ASTRA_SUBAGENT_MODEL) {
-        return 'SKS children must use gpt-6-astra. Retry spawn_agent with model="gpt-6-astra", task-appropriate reasoning_effort, and fork_turns="none" or a positive bounded turn count. Include the complete slice contract in message; do not inherit the parent model.';
+    if (!SEALED_CHILD_MODELS.has(String(input.model || ''))) {
+        return 'SKS children must use a sealed model: gpt-5.6-luna, gpt-5.6-sol, gpt-5.6-terra, or gpt-6-astra. Retry spawn_agent with that model, task-appropriate reasoning_effort, and fork_turns="none" or a positive bounded turn count. Include the complete slice contract in message; do not inherit the parent model.';
     }
     if (input.fork_turns !== 'none' && !/^[1-9]\d*$/.test(String(input.fork_turns || ''))) {
         return 'SKS Astra child spawns require fork_turns="none" or a positive bounded turn count. Retry with the complete slice contract in message; full-history/default forks cannot carry an explicit child model.';

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

@@ -1,4 +1,4 @@
-import { ASTRA_SUBAGENT_MODEL, decideSubagentModel, subagentModelProfile } from '../subagents/model-policy.js';
+import { ASTRA_SUBAGENT_MODEL, NARUTO_LUNA_MODEL, NARUTO_SOL_MODEL, NARUTO_TERRA_MODEL, decideSubagentModel, subagentModelProfile } from '../subagents/model-policy.js';
 const CATEGORY_POLICY = {
     quick: { reasoning: 'low', serviceTier: 'fast' },
     standard: { reasoning: 'medium', serviceTier: 'fast' },
@@ -10,7 +10,7 @@ const CATEGORY_POLICY = {
     refactor: { reasoning: 'max', serviceTier: 'fast' },
     strategy: { reasoning: 'max', serviceTier: 'fast' }
 };
-export const NARUTO_MODELS = [ASTRA_SUBAGENT_MODEL];
+export const NARUTO_MODELS = [NARUTO_LUNA_MODEL, NARUTO_SOL_MODEL, NARUTO_TERRA_MODEL, ASTRA_SUBAGENT_MODEL];
 const E2E_WORK_RE = /(e2e|end[-\s]?to[-\s]?end|test_execution|browser|chrome|computer[-\s]?use|computer\s+use|cross[-\s]?app|playwright|selenium|puppeteer|브라우저|컴퓨터\s*유즈)/i;
 export async function routeModel(category, opts = {}) {
     if (opts.narutoOnly) {
@@ -47,7 +47,7 @@ export function routeNarutoGpt56Model(input = {}) {
             || category === 'ultrabrain'
             || explicitHighRisk
     });
-    const preferred = explicit || automatic.model;
+    const preferred = explicit || ASTRA_SUBAGENT_MODEL;
     const available = input.availableModels == null
         ? [...NARUTO_MODELS]
         : input.availableModels.map(normalizeNarutoGpt56Model).filter((model) => Boolean(model));

package/dist/core/routes.js

@@ -706,7 +706,8 @@ export const COMMAND_CATALOG = [
     { name: 'gc', usage: 'sks gc [--dry-run] [--json]', description: 'Compact oversized logs and prune stale runtime artifacts.' },
     { name: 'stats', usage: 'sks stats [--full] [--json]', description: 'Show package and .sneakoscope storage size.' },
     { name: 'mcp-server', usage: 'sks mcp-server [--expose-exec] [--probe]', description: 'Run a modern stateless stdio MCP server exposing SKS read-only commands as tools for any MCP-capable agent host; --expose-exec also exposes non-read-only commands; --probe round-trips server/discover and tools/list, then exits.' },
-    { name: 'agent-bridge', usage: 'sks agent-bridge setup [--trusted-project] [--json] | async --prompt "task" [--tools status,stats] [--json]', description: 'Publish the agent-bridge manifest or run selected read-only SKS tools with native Astra Async tool calling through the registered Codex-LB bridge.' }
+    { name: 'agent-bridge', usage: 'sks agent-bridge setup [--trusted-project] [--json] | async --prompt "task" [--tools status,stats] [--json]', description: 'Publish the agent-bridge manifest or run selected read-only SKS tools with native Astra Async tool calling through the registered Codex-LB bridge.' },
+    { name: 'decision', usage: 'sks decision status|enable|disable|probe|evaluate [--json]', description: 'Manage optional Jev decisions through the existing OpenRouter credential (off by default). Enable records cloud consent; a valid answer is compiled into SKS plan or context selection. There is no advisory mode and no local model runtime.' }
 ];
 export function routeById(id) {
     const key = String(id || '').replace(/^\$/, '').toLowerCase();

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

@@ -1,6 +1,9 @@
 export const NARUTO_PARENT_MODEL = 'gpt-6-astra';
 export const NARUTO_PARENT_EFFORT = 'max';
 export const ASTRA_SUBAGENT_MODEL = 'gpt-6-astra';
+export const NARUTO_LUNA_MODEL = 'gpt-5.6-luna';
+export const NARUTO_SOL_MODEL = 'gpt-5.6-sol';
+export const NARUTO_TERRA_MODEL = 'gpt-5.6-terra';
 export const LUNA_SUBAGENT_MODEL = ASTRA_SUBAGENT_MODEL;
 export const TERRA_SUBAGENT_MODEL = ASTRA_SUBAGENT_MODEL;
 export const SOL_SUBAGENT_MODEL = ASTRA_SUBAGENT_MODEL;
@@ -271,6 +274,18 @@ const DOCUMENT_EXPLORATION_RE = /\b(?:read|scan|explore|compare|summarize|review
 export function subagentModelProfile(policy) {
     return SUBAGENT_MODEL_POLICIES[policy];
 }
+export function narutoChildAssignment(policy) {
+    switch (policy) {
+        case 'luna_max_mechanical':
+            return { model: NARUTO_LUNA_MODEL, effort: 'low' };
+        case 'sol_high_implementation':
+            return { model: NARUTO_SOL_MODEL, effort: 'low' };
+        case 'terra_max_context_tools':
+            return { model: NARUTO_TERRA_MODEL, effort: 'medium' };
+        case 'sol_max_judgment':
+            return { model: ASTRA_SUBAGENT_MODEL, effort: 'max' };
+    }
+}
 export function decideSubagentModel(input = {}) {
     const text = [
         input.title,

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

@@ -0,0 +1,15 @@
+import path from 'node:path';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { withFileLock } from '../locks/file-lock.js';
+export const OFFICIAL_SUBAGENT_LIFECYCLE_LOCK = '.subagent-evidence.lock';
+const lockStore = new AsyncLocalStorage();
+export function officialSubagentLifecycleLockHeld() {
+    return lockStore.getStore() === true;
+}
+export function withOfficialSubagentLifecycleLock(dir, fn) {
+    return withFileLock({
+        lockPath: path.join(dir, OFFICIAL_SUBAGENT_LIFECYCLE_LOCK),
+        timeoutMs: 5_000,
+        staleMs: 60_000
+    }, () => lockStore.run(true, fn));
+}