sneakoscope 10.2.0 → 10.3.0

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

@@ -17,35 +17,91 @@ import { readRoleModelPreferences } from './role-model-preferences.js';
 import { readConfiguredCodexModelRoutingContext } from '../codex-app/codex-model-catalog.js';
 import { SUBAGENT_EVIDENCE_FILENAME, SUBAGENT_EVENT_LOG_FILENAME, SUBAGENT_PARENT_SUMMARY_FILENAME, normalizeSubagentParentSummary, writeSubagentEvidence } from './subagent-evidence.js';
 import { sksPrefixedDollarCommand, unprefixedSksSkillName } from '../routes/dollar-prefix.js';
-import { withFileLock, tryWithFileLock } from '../locks/file-lock.js';
+import { tryWithFileLock } from '../locks/file-lock.js';
 import { updateCurrentIfMissionAndRun } from '../mission.js';
 import { HOST_CAPABILITY_HOOK_EVIDENCE_FILENAME, HOST_CAPABILITY_HOOK_OBSERVATIONS_FILENAME, HOST_CAPABILITY_HOOK_PENDING_RUNTIME_FILENAME, HOST_CAPABILITY_HOOK_RUNTIME_FILENAME } from '../agent-bridge/host-capability-runtime.js';
 import { uniqueStrings } from '../text/strings.js';
 import { officialSubagentEvidenceReady } from './terminal-subagent-state.js';
+import { OFFICIAL_SUBAGENT_LIFECYCLE_LOCK, withOfficialSubagentLifecycleLock } from './official-subagent-lock.js';
+import { decideOfficialSubagentPreparation } from '../decisions/integration.js';
+import { applySealedRouting } from '../decisions/routing.js';
+import { graphFileDigest, sourceSnapshotDigest } from '../decisions/state.js';
+export { OFFICIAL_SUBAGENT_LIFECYCLE_LOCK, withOfficialSubagentLifecycleLock };
 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';
 export const NARUTO_GATE_FILENAME = 'naruto-gate.json';
-export const OFFICIAL_SUBAGENT_LIFECYCLE_LOCK = '.subagent-evidence.lock';
 export const OFFICIAL_SUBAGENT_PREPARATION_TRANSACTION = '.official-subagent-preparation-transaction.json';
 export const SUBAGENT_LIFECYCLE_CAPTURE_FAILURE_DIR = 'subagent-lifecycle-capture-failures';
 const OFFICIAL_SUBAGENT_PREPARATION_STAGE_PREFIX = '.official-subagent-preparation-stage-';
-export function withOfficialSubagentLifecycleLock(dir, fn) {
-    return withFileLock({
-        lockPath: path.join(dir, OFFICIAL_SUBAGENT_LIFECYCLE_LOCK),
-        timeoutMs: 5_000,
-        staleMs: 60_000
-    }, fn);
-}
 export async function prepareOfficialSubagentMission(input) {
-    return withOfficialSubagentLifecycleLock(input.dir, () => prepareOfficialSubagentMissionLocked(input));
+    const opened = await withOfficialSubagentLifecycleLock(input.dir, () => openOfficialSubagentPreparation(input));
+    if (opened.kind === 'recovered')
+        return opened.result;
+    const derived = await deriveOfficialSubagentPreparation(input, opened.snapshot);
+    const decided = await decideOfficialSubagentPreparation({
+        root: input.root,
+        dir: input.dir,
+        missionId: input.missionId,
+        goal: String(input.goal || '').trim(),
+        workflowRunId: derived.workflowRunId,
+        workflowRevision: opened.snapshot.workflowRevision,
+        slices: derived.slices,
+        requestedSource: derived.requestedSource,
+        requestedSubagents: derived.budget.requestedSubagents,
+        attention: derived.triwikiAttention,
+        changedPaths: derived.sliceWriteScopes,
+        massParallel: derived.fanoutPolicy.mass_parallel === true,
+        routingRoles: derived.mode === 'naruto'
+            ? routingRolesFromAgents(derived.agentRouting, derived.slices.map((slice) => slice.agent || ''))
+            : [],
+        env: input.env || process.env
+    });
+    const rebuilt = applyOfficialSubagentDecision(derived, decided);
+    return withOfficialSubagentLifecycleLock(input.dir, () => commitOfficialSubagentPreparation(input, opened.snapshot, rebuilt));
 }
-async function prepareOfficialSubagentMissionLocked(input) {
+async function openOfficialSubagentPreparation(input) {
     const recovered = await recoverOfficialSubagentPreparationTransaction(input);
     if (recovered)
-        return recovered;
+        return { kind: 'recovered', result: recovered };
     const previousPlan = await readJson(path.join(input.dir, SUBAGENT_PLAN_FILENAME), null).catch(() => null);
-    const expectedWorkflowRunId = String(previousPlan?.workflow_run_id || '').trim();
+    const sourceDigest = await sourceSnapshotDigest(input.root);
+    const graphDigest = await graphFileDigest(input.root);
+    return {
+        kind: 'snapshot',
+        snapshot: {
+            previousWorkflowRunId: String(previousPlan?.workflow_run_id || '').trim(),
+            sourceDigest,
+            graphDigest,
+            workflowRevision: `${sourceDigest}:${graphDigest || 'no-graph'}`
+        }
+    };
+}
+async function commitOfficialSubagentPreparation(input, snapshot, derived) {
+    const recovered = await recoverOfficialSubagentPreparationTransaction(input);
+    if (recovered)
+        return recovered;
+    const currentPlan = await readJson(path.join(input.dir, SUBAGENT_PLAN_FILENAME), null).catch(() => null);
+    const currentRunId = String(currentPlan?.workflow_run_id || '').trim();
+    const currentSource = await sourceSnapshotDigest(input.root);
+    const currentGraph = await graphFileDigest(input.root);
+    if ((currentRunId && currentRunId !== snapshot.previousWorkflowRunId)
+        || currentSource !== snapshot.sourceDigest
+        || currentGraph !== snapshot.graphDigest) {
+        if (currentPlan && String(currentPlan.goal || '') === String(input.goal || '').trim()
+            && String(currentPlan.route || '') === String(input.route || '')) {
+            return {
+                ...derived.preparedResultBase,
+                plan: currentPlan,
+                evidence: await readJson(path.join(input.dir, SUBAGENT_EVIDENCE_FILENAME), null).catch(() => null)
+            };
+        }
+        throw new Error('official_subagent_preparation_stale_snapshot');
+    }
+    return promoteOfficialSubagentDerived(input, derived, snapshot.previousWorkflowRunId);
+}
+async function deriveOfficialSubagentPreparation(input, snapshot) {
+    const expectedWorkflowRunId = snapshot.previousWorkflowRunId;
     const goal = String(input.goal || '').trim();
     const mode = input.mode === 'naruto' ? 'naruto' : 'generic';
     const taskProfile = classifyTaskProfile(goal);
@@ -208,15 +264,13 @@ async function prepareOfficialSubagentMissionLocked(input) {
             readonly: config.sandbox_mode === 'read-only'
         });
         const preference = roleModelPreferences.store.roles[name];
-        const routedProvider = 'openai';
-        const routedModel = ASTRA_SUBAGENT_MODEL;
         const routedReasoning = preference?.reasoning_effort
             || config.model_reasoning_effort
             || decision.model_reasoning_effort;
         return [name, {
                 ...config,
-                routed_provider: routedProvider,
-                routed_model: routedModel,
+                routed_provider: 'openai',
+                routed_model: preference?.model || ASTRA_SUBAGENT_MODEL,
                 routed_model_reasoning_effort: routedReasoning,
                 routed_model_policy: preference
                     ? 'user_role_model_preference'
@@ -320,7 +374,6 @@ async function prepareOfficialSubagentMissionLocked(input) {
         verification: { budget: verification },
         created_at: nowIso()
     };
-    const statePatch = input.statePatch?.({ plan, budget, workflowRunId }) || null;
     const preparedResultBase = {
         plan,
         budget,
@@ -336,19 +389,202 @@ async function prepareOfficialSubagentMissionLocked(input) {
         observedParentModel,
         parentModelMatch
     };
+    return {
+        preparedResultBase,
+        slices,
+        requestedSource,
+        sliceWriteScopes,
+        sliceSafety,
+        suggestedAgents,
+        roleModelPreferences,
+        roleModelRouting,
+        activeMainModel,
+        officialConfig,
+        selectedFanoutPolicy,
+        configuredMaxThreads,
+        externalCodexHostCap,
+        externalCodexHostCapVerification,
+        taskProfile,
+        mode,
+        goal,
+        delegationGoal,
+        observedParentModel,
+        parentModelMatch,
+        workflowRunId,
+        expectedWorkflowRunId,
+        ssotGuard,
+        verification,
+        budget,
+        fanoutPolicy,
+        agentRouting,
+        agentCatalog,
+        routeContract,
+        operatorRequested,
+        requestedSubagents,
+        triwikiAttention,
+        configBlockers,
+        plan,
+        sessionScope: input.sessionScope || null
+    };
+}
+function routingRolesFromAgents(agentRouting, preferredNames = []) {
+    const preferred = new Set(preferredNames.filter(Boolean));
+    const entries = Object.entries(agentRouting);
+    const ordered = [
+        ...entries.filter(([name]) => preferred.has(name)),
+        ...entries.filter(([name]) => !preferred.has(name))
+    ];
+    return ordered.flatMap(([name, row]) => {
+        if (row?.routing_dynamic !== true || row.routed_model_policy === 'user_role_model_preference')
+            return [];
+        return [{
+                name,
+                dynamic: true,
+                summary: String(row.description || name)
+            }];
+    });
+}
+function applyOfficialSubagentDecision(derived, decided) {
+    const attention = decided.attention;
+    const selectedPlan = derived.requestedSource === 'automatic' ? decided.selectedPlan : null;
+    const selectedRouting = derived.requestedSource === 'automatic' ? decided.selectedRouting : null;
+    const agents = applySealedRouting(derived.plan.agents, selectedRouting);
+    const budget = selectedPlan
+        ? rebuildBudget(derived, selectedPlan)
+        : derived.budget;
+    let fanoutPolicy = selectedPlan
+        ? {
+            ...derived.fanoutPolicy,
+            requested_subagents: budget.requestedSubagents,
+            jev_selected_plan: selectedPlan.id
+        }
+        : { ...derived.fanoutPolicy };
+    if (selectedRouting)
+        fanoutPolicy = { ...fanoutPolicy, jev_selected_routing: selectedRouting.id };
+    const routingPreferences = selectedRouting
+        ? Object.fromEntries(Object.entries(selectedRouting.efforts)
+            .filter(([name]) => !derived.roleModelPreferences.store.roles[name])
+            .map(([name, effort]) => [name, {
+                provider: 'openai',
+                model: selectedRouting.models[name] || 'gpt-6-astra',
+                reasoning_effort: effort,
+                updated_at: derived.plan.workflow_run_id
+            }]))
+        : {};
+    const delegationPrompt = buildOfficialSubagentPrompt({
+        goal: derived.delegationGoal,
+        slices: derived.slices,
+        requestedSubagents: budget.requestedSubagents,
+        requestedSubagentsExplicit: derived.requestedSource === 'operator',
+        requestedSubagentsSource: derived.requestedSource,
+        maxThreads: budget.maxThreads,
+        decompositionStatus: derived.plan.decomposition_status,
+        firstWave: budget.firstWave,
+        waveCount: budget.waveCount,
+        capacity: budget.capacity,
+        triwikiAttention: attention,
+        recommendedAgents: derived.suggestedAgents,
+        roleModelPreferences: {
+            ...derived.roleModelPreferences.store.roles,
+            ...routingPreferences
+        },
+        routedAgents: agents,
+        narutoChildRouting: derived.mode === 'naruto',
+        activeMainModel: derived.activeMainModel,
+        parentOutputMode: derived.mode === 'naruto' && derived.sessionScope ? 'app_naruto_stdin' : 'raw_json',
+        missionId: derived.plan.mission_id,
+        workflowRunId: derived.workflowRunId,
+        decisionContract: decided.compiled.kind === 'apply'
+            ? {
+                planId: selectedPlan?.id ?? null,
+                keepContextIds: decided.selectedContextIds,
+                routingLane: selectedRouting
+                    ? Object.entries(selectedRouting.models).map(([name, model]) => `${name}=${model}`).join(', ')
+                    : null,
+                executeSelectedIds: true
+            }
+            : null
+    });
+    const plan = {
+        ...derived.plan,
+        delegation_prompt: delegationPrompt,
+        requested_subagents: budget.requestedSubagents,
+        first_wave: budget.firstWave,
+        wave_count: budget.waveCount,
+        wave_lifecycle: createSubagentWaveLifecycle({
+            workflowRunId: derived.workflowRunId,
+            targetSubagents: budget.requestedSubagents,
+            countPolicy: derived.requestedSource === 'automatic' ? 'dynamic_automatic' : 'exact',
+            waveCapacity: budget.firstWave
+        }),
+        triwiki_attention: attention,
+        agents,
+        fanout_policy: fanoutPolicy,
+        capacity_controller: budget.capacity,
+        jev_decision: decided.receipt,
+        native_host_dispatch: 'unverified'
+    };
+    return {
+        ...derived,
+        budget,
+        fanoutPolicy,
+        triwikiAttention: attention,
+        plan,
+        preparedResultBase: {
+            ...derived.preparedResultBase,
+            plan,
+            budget,
+            delegationPrompt,
+            triwikiAttention: attention,
+            fanoutPolicy
+        }
+    };
+}
+function rebuildBudget(derived, selectedPlan) {
+    const requested = selectedPlan.workerCount;
+    const waveGovernor = decideNarutoConcurrency({
+        requestedWorkers: Math.min(requested, derived.configuredMaxThreads),
+        totalWorkItems: requested,
+        backend: 'official-subagent',
+        parallelismMode: 'extreme',
+        maxThreads: derived.configuredMaxThreads,
+        ...(derived.externalCodexHostCap === undefined ? {} : { externalCodexHostCap: derived.externalCodexHostCap })
+    });
+    return resolveSubagentThreadBudget({
+        requested,
+        configuredMaxThreads: derived.configuredMaxThreads,
+        ...(derived.externalCodexHostCap === undefined ? {} : { externalCodexHostCap: derived.externalCodexHostCap }),
+        marginalUsefulWorkers: waveGovernor.safe_active_workers,
+        reviewerReservedThreads: String(derived.fanoutPolicy.selection_reason || '').includes('reviewer')
+            || derived.fanoutPolicy.critical_multi_domain === true
+            ? Math.max(1, Number(derived.fanoutPolicy.automatic_reviewer_ceiling || 1))
+            : 0,
+        ...(derived.slices.length > 0
+            ? {
+                independentSliceCount: derived.slices.length,
+                readyDagWidth: derived.slices.length,
+                disjointOwnershipCount: derived.sliceSafety.safe ? derived.slices.length : 0
+            }
+            : {})
+    });
+}
+async function promoteOfficialSubagentDerived(input, derived, expectedWorkflowRunId) {
+    const { plan, budget, verification, workflowRunId, officialConfig, triwikiAttention, suggestedAgents, fanoutPolicy, configBlockers, observedParentModel, parentModelMatch, taskProfile, delegationPrompt } = derived.preparedResultBase;
+    const statePatch = input.statePatch?.({ plan, budget, workflowRunId }) || null;
+    const preparedResultBase = derived.preparedResultBase;
     const transactionFile = path.join(input.dir, OFFICIAL_SUBAGENT_PREPARATION_TRANSACTION);
     const stageName = `${OFFICIAL_SUBAGENT_PREPARATION_STAGE_PREFIX}${safePreparationStageId(workflowRunId)}`;
     const stageDir = path.join(input.dir, stageName);
-    const artifactInventory = officialSubagentPreparationArtifactInventory(mode);
-    const tombstoneInventory = officialSubagentPreparationTombstoneInventory(mode);
+    const artifactInventory = officialSubagentPreparationArtifactInventory(derived.mode);
+    const tombstoneInventory = officialSubagentPreparationTombstoneInventory(derived.mode);
     let transaction = {
         schema: 'sks.official-subagent-preparation-transaction.v2',
         status: 'staging',
         mission_id: input.missionId,
         session_scope: input.sessionScope || null,
         route: input.route,
-        mode,
-        goal,
+        mode: derived.mode,
+        goal: derived.goal,
         previous_workflow_run_id: expectedWorkflowRunId || null,
         target_workflow_run_id: workflowRunId,
         stage_dir: stageName,
@@ -365,9 +601,9 @@ async function prepareOfficialSubagentMissionLocked(input) {
     await fsp.rm(stageDir, { recursive: true, force: true });
     await fsp.mkdir(stageDir, { recursive: true });
     const evidence = await writeOfficialSubagentPreparationStage(stageDir, {
-        mode,
+        mode: derived.mode,
         plan,
-        ssotGuard,
+        ssotGuard: derived.ssotGuard,
         budget,
         workflowRunId,
         preparationOnly: input.preparationOnly !== false,
@@ -409,6 +645,11 @@ async function prepareOfficialSubagentMissionLocked(input) {
     return {
         ...preparedResultBase,
         evidence,
+        officialConfig,
+        triwikiAttention,
+        fanoutPolicy,
+        taskProfile,
+        delegationPrompt
     };
 }
 async function recoverOfficialSubagentPreparationTransaction(input) {

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

@@ -23,6 +23,7 @@ export function buildOfficialSubagentPrompt(input) {
             ? `${requestedSubagents} (route-owned exact orchestration contract)`
             : `${requestedSubagents} (dynamic automatic target; keep the final decomposed plan and evidence count exact)`;
     const triwiki = renderBoundedTriwikiAttention(input.triwikiAttention);
+    const decisionContract = renderDecisionContract(input.decisionContract);
     const resolvedSlices = input.slices.map((slice) => ({
         slice,
         agentName: slice.agent || selectOfficialSubagentRole({
@@ -48,7 +49,23 @@ export function buildOfficialSubagentPrompt(input) {
         && ['low', 'medium', 'high', 'xhigh', 'max', 'ultra'].includes(row.reasoning_effort)
         && officialSubagentOnDemandRoleCatalog([name]).some((role) => role.name === name))
         .map(([name, row]) => [name, row.reasoning_effort]));
-    const spawnModelRouting = renderSpawnModelRouting();
+    const narutoChildren = input.narutoChildRouting === true;
+    const spawnModelRouting = renderSpawnModelRouting(narutoChildren);
+    const childModelRules = narutoChildren
+        ? [
+            '- use the model and reasoning_effort named in each slice spawn contract',
+            '- sealed child models are gpt-5.6-luna, gpt-5.6-sol, gpt-5.6-terra, and gpt-6-astra',
+            '- keep a stored user role-model preference for that role'
+        ].join('\n')
+        : [
+            '- use `worker` with gpt-6-astra and low reasoning for tiny short-context mechanical work such as simple search, typing, rename, copy, label, or one-line edits with no exploration or judgment',
+            '- use gpt-6-astra with low reasoning for ordinary UI, logic, backend, and native implementation with established instructions',
+            '- use gpt-6-astra with max reasoning for planning, analysis, review, focused unresolved, high-risk, architecture, security, database, research, release, or other explicit judgment slices',
+            '- use gpt-6-astra with medium reasoning for long context/memory, large docs/repository reads or exploration, large-scale first-draft code processing, and direct Computer Use, Browser/Chrome, or image generation',
+            '- explicit task class and phase win over incidental keywords: Astra Medium explores, Astra Low executes mechanical and instructed coding tasks, and Astra Max judges',
+            '- in mass fan-out, use worker/Astra Low for tiny mechanical shards and explorer/Astra Medium for broad exploration; use Astra Low for instructed implementation and Astra Max for judgment',
+            '- keep context, exploration, review, debugging, planning, and direct tool operation on their assigned defaults; preserve each sealed role model and effort instead of applying the parent profile to every child'
+        ].join('\n');
     const parentOutputMode = input.parentOutputMode === 'app_naruto_stdin'
         ? 'app_naruto_stdin'
         : 'raw_json';
@@ -56,9 +73,14 @@ export function buildOfficialSubagentPrompt(input) {
         const mode = slice.readOnly ? 'read-only' : 'use the parent permission mode';
         const paths = (slice.paths || []).map((entry) => String(entry).trim()).filter(Boolean);
         const role = officialSubagentOnDemandRoleCatalog([agentName])[0];
-        const sealedReasoning = effortPreferences[agentName] || role?.model_reasoning_effort || 'medium';
+        const routed = input.routedAgents?.[agentName];
+        const sealedReasoning = routed?.routed_model_reasoning_effort
+            || effortPreferences[agentName]
+            || role?.model_reasoning_effort
+            || 'medium';
+        const sealedModel = routed?.routed_model || role?.model;
         const spawnContract = role
-            ? `pass model=${JSON.stringify(role.model)} and reasoning_effort=${JSON.stringify(sealedReasoning)} from the sealed role policy`
+            ? `pass model=${JSON.stringify(sealedModel)} and reasoning_effort=${JSON.stringify(sealedReasoning)} from the sealed role policy`
             : 'stop before spawning: resolve an installed sealed Astra role and its effort first';
         return [
             `${index + 1}. [${slice.id}] use custom agent \`${agentName}\``,
@@ -94,18 +116,12 @@ Subagent rules:
 - use only Codex official subagent threads; do not launch shell workers, a custom scheduler, a worker pool, or model fanout
 - select the narrowest matching project custom agent by its description; the custom agent name is the spawn type
 - custom \`agent_type\` selection and spawn-time \`model\`/\`reasoning_effort\` overrides must use \`fork_turns="none"\` or a positive bounded turn count, with the complete bounded slice contract in \`message\`; context contract: pass fork_turns="none" for listed slices
-- \`spawn_agent\` has no provider argument; every child uses the exact model slug gpt-6-astra
+- \`spawn_agent\` has no provider argument; ${narutoChildren ? 'Naruto children use the sealed model named in the spawn contract (gpt-5.6-luna, gpt-5.6-sol, gpt-5.6-terra, or gpt-6-astra)' : 'every child uses the exact model slug gpt-6-astra'}
 - never combine \`fork_turns="all"\` or the omitted/default full-history mode with \`agent_type\`, \`model\`, or \`reasoning_effort\`; Codex rejects that start before SubagentStart
 - never use a full-history fork for SKS children
 ${spawnModelRouting}
 ${Object.keys(effortPreferences).length ? `- explicit Astra effort preferences override role defaults, including later slices: ${JSON.stringify(effortPreferences)}` : ''}
-- use \`worker\` with gpt-6-astra and low reasoning for tiny short-context mechanical work such as simple search, typing, rename, copy, label, or one-line edits with no exploration or judgment
-- use gpt-6-astra with low reasoning for ordinary UI, logic, backend, and native implementation with established instructions
-- use gpt-6-astra with max reasoning for planning, analysis, review, focused unresolved, high-risk, architecture, security, database, research, release, or other explicit judgment slices
-- use gpt-6-astra with medium reasoning for long context/memory, large docs/repository reads or exploration, large-scale first-draft code processing, and direct Computer Use, Browser/Chrome, or image generation
-- explicit task class and phase win over incidental keywords: Astra Medium explores, Astra Low executes mechanical and instructed coding tasks, and Astra Max judges
-- in mass fan-out, use worker/Astra Low for tiny mechanical shards and explorer/Astra Medium for broad exploration; use Astra Low for instructed implementation and Astra Max for judgment
-- keep context, exploration, review, debugging, planning, and direct tool operation on their assigned defaults; preserve each sealed role model and effort instead of applying the parent profile to every child
+${childModelRules}
 
 Plan and capacity:
 - automatic fan-out is capacity-derived up to ${MAX_AUTOMATIC_SUBAGENT_COUNT}: after decomposition, use every safe useful child slot supported by the ready DAG, disjoint ownership, verifier/tool capacity, and actual host limits; the historical 4/6/8/16 task-class values are fallback hints, not clamps
@@ -141,6 +157,7 @@ ${renderSliceSafety(sliceSafety, parentDecompositionRequired)}
 
 Central TriWiki context:
 ${triwiki}
+${decisionContract}
 
 Project custom agent catalog:
 ${catalog}
@@ -209,7 +226,15 @@ function normalizedActiveMainModel(value) {
     const model = String(value?.model || '').trim();
     return provider && model ? { provider, model } : null;
 }
-function renderSpawnModelRouting() {
+function renderSpawnModelRouting(narutoChildRouting) {
+    if (narutoChildRouting) {
+        return [
+            '- Naruto child models come from the spawn contract, including slices created after parent decomposition',
+            '- when Jev mode selected a role, that contract names gpt-5.6-luna at low, gpt-5.6-sol at low, gpt-5.6-terra at medium, or gpt-6-astra at max',
+            '- explicit user role-model preferences stay authoritative',
+            '- preserve the user-selected parent model, reasoning effort, and service tier'
+        ].join('\n');
+    }
     return [
         '- model routing applies to every child, including slices created after parent decomposition: gpt-6-astra only, with the selected role effort',
         '- use sealed Astra Low/Astra Medium/Astra Max role defaults across four task-class profiles; parent selection and saved non-Astra preferences never override the child model; explicit Astra effort preferences, including High, may override role defaults',
@@ -282,15 +307,33 @@ function renderBoundedTriwikiAttention(value) {
         id: anchor.id,
         claim_hash: anchor.claim_hash,
         source_hash: anchor.source_hash,
-        hydrate_hint: anchor.hydrate_hint
+        hydrate_hint: anchor.hydrate_hint,
+        ...(anchor.source_path ? { source_path: anchor.source_path } : {}),
+        ...(anchor.excerpt ? { excerpt: anchor.excerpt } : {})
     }));
+    const hasExcerpt = value.anchors.some((anchor) => Boolean(anchor.excerpt));
     return [
         `- consume these ${anchors.length} attention.use_first anchors before broad discovery`,
         '- hydrate a referenced source only when its anchor is relevant to the assigned slice or a risky decision',
         '- do not inject the full context pack or make each subagent repeat repository-wide context discovery',
+        ...(hasExcerpt
+            ? ['- keep exact source text and provenance; do not summarize selected excerpts with another model']
+            : []),
         `- bounded anchors: ${JSON.stringify(anchors)}`
     ].join('\n');
 }
+function renderDecisionContract(value) {
+    if (!value || value.executeSelectedIds !== true)
+        return '';
+    return [
+        'Selected decision contract:',
+        `- execute the selected plan${value.planId ? ` ${value.planId}` : ''} and retained optional context IDs; do not choose them again`,
+        value.routingLane ? `- Jev sealed models: ${value.routingLane}` : '',
+        value.keepContextIds?.length
+            ? `- retained optional context IDs: ${value.keepContextIds.join(', ')}`
+            : '- pinned and retained context already unioned by code'
+    ].filter(Boolean).join('\n');
+}
 function renderAgentCatalog(requested) {
     const names = [...new Set(requested.map(String).map((name) => name.trim()).filter(Boolean))];
     const selected = officialSubagentOnDemandRoleCatalog(names.length ? names : ['expert']);