sneakoscope 7.3.0 → 7.6.0

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

@@ -13,7 +13,8 @@ export function buildNarutoHelpResult() {
             'sks naruto run "<task>" [--agents N] [--max-threads N] [--trusted-project] [--json]',
             'sks naruto status [latest|M-...] [--json]',
             'sks naruto subagents [latest|M-...] [--json]',
-            'sks naruto proof [latest|M-...] [--json]'
+            'sks naruto proof [latest|M-...] [--json]',
+            'sks naruto parent-summary --mission M-... --stdin [--json] (active Codex App Naruto only)'
         ],
         commands: [...NARUTO_ACTIONS],
         default_requested_subagents: DEFAULT_AUTOMATIC_SUBAGENT_COUNT,

package/dist/core/subagents/naruto-host-credentials.js

@@ -0,0 +1,161 @@
+export const NARUTO_AUTH_MODES = ['managed', 'host'];
+const IDENTIFIER_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+export const NARUTO_EFFORT_TIERS = ['minimal', 'low', 'medium', 'high', 'max'];
+function readFlagValue(args, name) {
+    const inline = args.find((arg) => arg.startsWith(`${name}=`));
+    if (inline)
+        return inline.slice(name.length + 1);
+    const index = args.indexOf(name);
+    if (index >= 0) {
+        const next = args[index + 1];
+        if (next !== undefined && !next.startsWith('-'))
+            return next;
+    }
+    return null;
+}
+function resolve(args, env, flag, envKey) {
+    const fromFlag = readFlagValue(args, flag);
+    if (fromFlag !== null && fromFlag !== '')
+        return { value: fromFlag, source: 'flag' };
+    const fromEnv = env[envKey];
+    if (typeof fromEnv === 'string' && fromEnv.trim())
+        return { value: fromEnv.trim(), source: 'env' };
+    return { value: null, source: 'default' };
+}
+function validIdentifier(value) {
+    return IDENTIFIER_RE.test(value);
+}
+export function resolveNarutoCredentialPolicy(input) {
+    const args = input.args ?? [];
+    const env = input.env ?? process.env;
+    const warnings = [];
+    const blockers = [];
+    const sources = {};
+    const authModeRaw = resolve(args, env, '--auth-mode', 'SKS_NARUTO_AUTH_MODE');
+    let authMode = 'managed';
+    if (authModeRaw.value !== null) {
+        if (NARUTO_AUTH_MODES.includes(authModeRaw.value)) {
+            authMode = authModeRaw.value;
+            sources.authMode = authModeRaw.source;
+        }
+        else {
+            blockers.push(`naruto_auth_mode_invalid:${authModeRaw.value}`);
+        }
+    }
+    if (sources.authMode === undefined)
+        sources.authMode = 'default';
+    const providerRaw = resolve(args, env, '--model-provider', 'SKS_NARUTO_MODEL_PROVIDER');
+    let modelProvider = authMode === 'host' ? null : 'openai';
+    sources.modelProvider = 'default';
+    if (providerRaw.value !== null) {
+        if (!validIdentifier(providerRaw.value)) {
+            blockers.push(`naruto_model_provider_invalid:${providerRaw.value.slice(0, 32)}`);
+        }
+        else if (authMode === 'managed') {
+            blockers.push('naruto_model_provider_requires_host_auth_mode');
+        }
+        else {
+            modelProvider = providerRaw.value;
+            sources.modelProvider = providerRaw.source;
+        }
+    }
+    const noForcedLogin = args.includes('--no-forced-login-method')
+        || String(env.SKS_NARUTO_FORCED_LOGIN_METHOD ?? '').toLowerCase() === 'none';
+    let forcedLoginMethod = 'chatgpt';
+    sources.forcedLoginMethod = 'default';
+    if (authMode === 'host') {
+        forcedLoginMethod = null;
+        sources.forcedLoginMethod = sources.authMode;
+    }
+    else if (noForcedLogin) {
+        forcedLoginMethod = null;
+        sources.forcedLoginMethod = args.includes('--no-forced-login-method') ? 'flag' : 'env';
+        warnings.push('naruto_forced_login_method_released_without_host_auth_mode');
+    }
+    const models = [
+        { key: 'parentModel', flag: '--parent-model', envKey: 'SKS_NARUTO_PARENT_MODEL', fallback: input.defaultParentModel, effort: false },
+        { key: 'parentEffort', flag: '--parent-effort', envKey: 'SKS_NARUTO_PARENT_EFFORT', fallback: input.defaultParentEffort, effort: true },
+        { key: 'subagentModel', flag: '--subagent-model', envKey: 'SKS_NARUTO_SUBAGENT_MODEL', fallback: input.defaultSubagentModel, effort: false },
+        { key: 'subagentEffort', flag: '--subagent-effort', envKey: 'SKS_NARUTO_SUBAGENT_EFFORT', fallback: input.defaultSubagentEffort, effort: true }
+    ];
+    const resolvedModels = {};
+    for (const entry of models) {
+        const raw = resolve(args, env, entry.flag, entry.envKey);
+        if (raw.value === null) {
+            resolvedModels[entry.key] = entry.fallback;
+            sources[entry.key] = 'default';
+            continue;
+        }
+        const ok = entry.effort
+            ? NARUTO_EFFORT_TIERS.includes(raw.value)
+            : validIdentifier(raw.value);
+        if (!ok) {
+            blockers.push(`naruto_${String(entry.key)}_invalid:${raw.value.slice(0, 32)}`);
+            resolvedModels[entry.key] = entry.fallback;
+            sources[entry.key] = 'default';
+            continue;
+        }
+        resolvedModels[entry.key] = raw.value;
+        sources[entry.key] = raw.source;
+    }
+    const envKeyRaw = resolve(args, env, '--provider-env-key', 'SKS_NARUTO_PROVIDER_ENV_KEY');
+    let providerEnvKey = null;
+    sources.providerEnvKey = 'default';
+    if (envKeyRaw.value !== null) {
+        if (!/^[A-Z][A-Z0-9_]{0,63}$/.test(envKeyRaw.value)) {
+            blockers.push(`naruto_provider_env_key_invalid:${envKeyRaw.value.slice(0, 32)}`);
+        }
+        else if (authMode === 'managed') {
+            blockers.push('naruto_provider_env_key_requires_host_auth_mode');
+        }
+        else {
+            providerEnvKey = envKeyRaw.value;
+            sources.providerEnvKey = envKeyRaw.source;
+        }
+    }
+    if (authMode === 'host' && modelProvider === null) {
+        warnings.push('naruto_host_auth_mode_without_explicit_model_provider');
+    }
+    if (authMode === 'host' && providerEnvKey !== null && env[providerEnvKey] === undefined) {
+        blockers.push(`naruto_provider_env_key_absent:${providerEnvKey}`);
+    }
+    return {
+        schema: 'sks.naruto-credential-policy.v1',
+        authMode,
+        modelProvider,
+        forcedLoginMethod,
+        providerEnvKey,
+        parentModel: String(resolvedModels.parentModel),
+        parentEffort: String(resolvedModels.parentEffort),
+        subagentModel: String(resolvedModels.subagentModel),
+        subagentEffort: String(resolvedModels.subagentEffort),
+        sources,
+        warnings,
+        blockers
+    };
+}
+export function narutoCredentialConfigArgs(policy) {
+    const out = [];
+    if (policy.modelProvider)
+        out.push('-c', `model_provider="${policy.modelProvider}"`);
+    if (policy.forcedLoginMethod)
+        out.push('-c', `forced_login_method="${policy.forcedLoginMethod}"`);
+    return out;
+}
+export function narutoCredentialPolicyReceipt(policy) {
+    return {
+        schema: policy.schema,
+        auth_mode: policy.authMode,
+        model_provider: policy.modelProvider,
+        forced_login_method: policy.forcedLoginMethod,
+        provider_env_key: policy.providerEnvKey,
+        parent_model: policy.parentModel,
+        parent_effort: policy.parentEffort,
+        subagent_model: policy.subagentModel,
+        subagent_effort: policy.subagentEffort,
+        sources: policy.sources,
+        warnings: policy.warnings,
+        blockers: policy.blockers,
+        credential_handled_by: policy.authMode === 'host' ? 'host_config_toml_provider_block' : 'sks_managed_chatgpt_login'
+    };
+}

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

@@ -151,7 +151,10 @@ async function prepareOfficialSubagentMissionLocked(input) {
         triwikiAttention,
         recommendedAgents: suggestedAgents,
         roleModelPreferences: roleModelPreferences.store.roles,
-        activeMainModel
+        activeMainModel,
+        parentOutputMode: mode === 'naruto' && input.sessionScope ? 'app_naruto_stdin' : 'raw_json',
+        missionId: input.missionId,
+        workflowRunId
     });
     const selectedAgentPlan = officialSubagentOnDemandRolePlan(suggestedAgents);
     const agentRouting = Object.fromEntries(Object.entries(selectedAgentPlan).map(([name, config]) => {

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

@@ -45,6 +45,9 @@ export function buildOfficialSubagentPrompt(input) {
     const activeMainModel = normalizedActiveMainModel(input.activeMainModel);
     const inheritActiveMainOntoChildren = childInheritsActiveMainModel(activeMainModel?.model);
     const spawnModelRouting = renderSpawnModelRouting(activeMainModel);
+    const parentOutputMode = input.parentOutputMode === 'app_naruto_stdin'
+        ? 'app_naruto_stdin'
+        : 'raw_json';
     const rows = resolvedSlices.map(({ slice, agentName }, index) => {
         const mode = slice.readOnly ? 'read-only' : 'use the parent permission mode';
         const paths = (slice.paths || []).map((entry) => String(entry).trim()).filter(Boolean);
@@ -160,7 +163,13 @@ ${String(input.goal || '').trim()}
 Slices:
 ${rows || '(parent decomposition required before any subagent is spawned)'}
 
-Final parent output:
+${parentOutputMode === 'app_naruto_stdin'
+        ? renderAppNarutoParentOutput(input.missionId, input.workflowRunId)
+        : renderRawJsonParentOutput()}
+`.trim();
+}
+function renderRawJsonParentOutput() {
+    return `Final parent output:
 - return one JSON object as the final message; prose outside that object is not completion evidence
 - use this exact schema so SKS can correlate every stopped agent thread with a trustworthy parent outcome:
 {
@@ -200,7 +209,40 @@ Final parent output:
 - if changed_files is non-empty, include at least one passed named check or a specifically justified not_applicable verification row
 - use empty artifacts/capabilities_used arrays when no host capability was used; SKS overwrites these fields with observed Codex JSONL evidence before persistence
 - keep completion summary and Honest Mode wording inside the JSON fields; do not add prose outside the object
-`.trim();
+`;
+}
+function renderAppNarutoParentOutput(missionId, workflowRunId) {
+    const mission = String(missionId || '').trim();
+    const runId = String(workflowRunId || '').trim();
+    return `Final parent output for this active Codex App Naruto run:
+- build one exact JSON object using the strict sks.subagent-parent-summary.v1 schema below, with run_id=${JSON.stringify(runId || 'workflow_run_id from subagent-plan.json')}
+- send that object only through stdin to \`sks naruto parent-summary --mission ${mission || '<mission-id>'} --stdin --json\`; this command is the sole parent-summary commit path
+- do not expose, paste, quote, embed, or fence the JSON in the user-visible response
+- only after the command accepts the object, return concise Markdown in the user's language with completion summary, verification, remaining gaps/blockers, and Honest Mode
+- if the parent status, any thread outcome, or any blocker is blocked/failed, state the blocker or failure first and do not use completion or success wording
+- a successful visible response must contain an explicit completion summary and Honest Mode assessment; hard-blocked/failed responses state the blocker first instead
+- use this exact object schema for the stdin submission:
+{
+  "schema": "sks.subagent-parent-summary.v1",
+  "run_id": "workflow_run_id from subagent-plan.json",
+  "status": "completed|blocked|failed",
+  "summary": "Concise integrated result and Honest Mode assessment.",
+  "thread_outcomes": [
+    { "thread_id": "official agent/thread id", "status": "completed|blocked|failed", "summary": "slice result" }
+  ],
+  "changed_files": [],
+  "verification": [
+    { "name": "focused check", "status": "passed|not_applicable", "reason": "required when not_applicable" }
+  ],
+  "artifacts": [],
+  "capabilities_used": [],
+  "blockers": []
+}
+- include one thread_outcomes row for every requested subagent; a SubagentStop event alone never proves success
+- copy workflow_run_id from subagent-plan.json into run_id exactly so delayed or stale summaries cannot bind to another run
+- if changed_files is non-empty, include at least one passed named check or a specifically justified not_applicable verification row
+- use empty artifacts/capabilities_used arrays when no host capability was used; SKS replaces these fields with observed Codex JSONL evidence before canonical persistence
+`;
 }
 function renderRoleModelPreferenceMetadata(preferences, activeMainModel) {
     const rows = Object.entries(preferences || {}).map(([role, preference]) => ({

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

@@ -9,6 +9,7 @@ import { resolveOfficialCodexPackageRuntime } from '../codex-runtime/resolve-cod
 import { withFileLock } from '../locks/file-lock.js';
 import { HOST_CAPABILITY_HOOK_PENDING_RUNTIME_FILENAME, HOST_CAPABILITY_MCP_SERVER, createHostCapabilityHookPendingRuntime, createHostCapabilityEventCollector, hostCapabilityCodexConfigArgs, inspectHostCapabilityRuntime, requestHostCapabilities } from '../agent-bridge/host-capability-runtime.js';
 import { uniqueStringsSorted as uniqueStrings } from '../text/strings.js';
+import { narutoCredentialConfigArgs, resolveNarutoCredentialPolicy } from './naruto-host-credentials.js';
 export const OFFICIAL_SUBAGENT_WORKFLOW_SCHEMA = 'sks.subagent-workflow.v1';
 function officialSubagentMissionDir(root, missionId) {
     return path.join(root, '.sneakoscope', 'missions', missionId);
@@ -82,23 +83,33 @@ export function codexAppSessionKey(env = process.env) {
     const threadId = String(env.CODEX_THREAD_ID || '').trim();
     return threadId || null;
 }
+export function defaultNarutoCredentialPolicy() {
+    return resolveNarutoCredentialPolicy({
+        args: [],
+        env: {},
+        defaultParentModel: NARUTO_PARENT_MODEL,
+        defaultParentEffort: NARUTO_PARENT_EFFORT,
+        defaultSubagentModel: DEFAULT_SUBAGENT_MODEL,
+        defaultSubagentEffort: DEFAULT_SUBAGENT_EFFORT
+    });
+}
 export function buildOfficialSubagentCodexArgs(input) {
     const maxThreads = Math.max(1, Math.floor(input.maxThreads));
     const maV2Total = maxThreads + 1;
+    const policy = input.credentialPolicy ?? defaultNarutoCredentialPolicy();
     return [
         'exec',
         '--json',
         ...(input.workingDirectory ? ['-C', input.workingDirectory] : []),
-        '-m', NARUTO_PARENT_MODEL,
-        '-c', `model_reasoning_effort="${NARUTO_PARENT_EFFORT}"`,
-        '-c', 'model_provider="openai"',
-        '-c', 'forced_login_method="chatgpt"',
+        '-m', policy.parentModel,
+        '-c', `model_reasoning_effort="${policy.parentEffort}"`,
+        ...narutoCredentialConfigArgs(policy),
         '-c', `features.multi_agent_v2={enabled=true,max_concurrent_threads_per_session=${maV2Total},expose_spawn_agent_model_overrides=true}`,
         '-c', 'agents.enabled=true',
         '-c', `agents.max_concurrent_threads_per_session=${maxThreads}`,
         '-c', 'agents.max_depth=1',
-        '-c', `agents.default_subagent_model="${DEFAULT_SUBAGENT_MODEL}"`,
-        '-c', `agents.default_subagent_reasoning_effort="${DEFAULT_SUBAGENT_EFFORT}"`,
+        '-c', `agents.default_subagent_model="${policy.subagentModel}"`,
+        '-c', `agents.default_subagent_reasoning_effort="${policy.subagentEffort}"`,
         '-c', 'agents.interrupt_message=true',
         ...(input.projectConfigArgs || []),
         ...(input.hostCapabilityConfigArgs || []),
@@ -113,6 +124,10 @@ export function buildOfficialSubagentChildEnv(input = {}) {
         if (source[key] !== undefined)
             childEnv[key] = source[key];
     }
+    const providerEnvKey = input.credentialPolicy?.providerEnvKey;
+    if (providerEnvKey && source[providerEnvKey] !== undefined) {
+        childEnv[providerEnvKey] = source[providerEnvKey];
+    }
     childEnv.SKS_NARUTO_STANDALONE_CLI = '0';
     childEnv.SKS_NARUTO_PARENT_LAUNCH = '1';
     if (input.missionId)
@@ -343,11 +358,13 @@ export async function runOfficialSubagentWorkflow(input) {
         hostCapabilityLaunchNonce = randomId(32);
         hostCapabilityPendingDir = officialSubagentMissionDir(canonicalRoot, input.missionId);
     }
+    const credentialPolicy = input.credentialPolicy ?? defaultNarutoCredentialPolicy();
     const childEnv = buildOfficialSubagentChildEnv({
         ...(input.env ? { env: input.env } : {}),
         ...(input.missionId ? { missionId: input.missionId } : {}),
         ...(input.workflowRunId ? { workflowRunId: input.workflowRunId } : {}),
-        ...(hostCapabilityLaunchNonce ? { hostCapabilityLaunchNonce } : {})
+        ...(hostCapabilityLaunchNonce ? { hostCapabilityLaunchNonce } : {}),
+        credentialPolicy
     });
     const outputSecretValues = hostCapabilityLaunchNonce
         ? [...inheritedSecretValues, hostCapabilityLaunchNonce]
@@ -450,7 +467,8 @@ export async function runOfficialSubagentWorkflow(input) {
             projectTrusted: input.projectTrusted === true,
             globalHostCapabilityConfigured
         }),
-        hostCapabilityConfigArgs: hostCapabilityCodexConfigArgs(hostCapabilityRuntime)
+        hostCapabilityConfigArgs: hostCapabilityCodexConfigArgs(hostCapabilityRuntime),
+        credentialPolicy
     });
     const toolOutputRecovery = await inspectCodexLbCliLaunchRecovery({
         root: input.root,

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

@@ -1,158 +1,170 @@
-import path from 'node:path';
-import { readJson } from '../fsx.js';
+import { CONTEXT_GRAPH_REPAIR_COMMAND } from '../triwiki/context-graph/contracts.js';
+import { readContextGraphAttention } from '../triwiki/context-graph/projections/attention.js';
 import { asRecordOrEmpty as asRecord } from '../json/records.js';
 export const BOUNDED_TRIWIKI_ATTENTION_SCHEMA = 'sks.subagent-triwiki-attention.v1';
 export const DEFAULT_TRIWIKI_ATTENTION_ANCHOR_LIMIT = 8;
-export async function readBoundedTriwikiAttention(root, limit = DEFAULT_TRIWIKI_ATTENTION_ANCHOR_LIMIT, query = '') {
-    const pack = await readJson(path.join(root, '.sneakoscope', 'wiki', 'context-pack.json'), null);
-    return extractBoundedTriwikiAttention(pack, limit, query);
+export const MAX_TRIWIKI_ATTENTION_ANCHOR_LIMIT = 16;
+export const DEFAULT_TRIWIKI_ATTENTION_TOKEN_BUDGET = 2000;
+export const TRIWIKI_ATTENTION_GRAPH_SOURCE = '.sneakoscope/wiki/context-graph.json';
+export const TRIWIKI_ATTENTION_PACK_SOURCE = '.sneakoscope/wiki/context-pack.json';
+export async function readBoundedTriwikiAttention(root, limit = DEFAULT_TRIWIKI_ATTENTION_ANCHOR_LIMIT, query = '', options = {}) {
+    const anchorLimit = normalizeLimit(limit);
+    const tokenBudget = Math.max(0, options.tokenBudget ?? DEFAULT_TRIWIKI_ATTENTION_TOKEN_BUDGET);
+    const result = await readContextGraphAttention({
+        root,
+        query,
+        limit: anchorLimit,
+        profile: options.profile ?? 'implementation',
+        tokenBudget,
+        risk: options.risk
+    }, options);
+    return {
+        schema: BOUNDED_TRIWIKI_ATTENTION_SCHEMA,
+        source: TRIWIKI_ATTENTION_GRAPH_SOURCE,
+        available: result.available,
+        attention_mode: result.available ? `context_graph:${result.profile}` : null,
+        anchor_limit: anchorLimit,
+        anchors: result.anchors.map(toAnchor),
+        hydration_policy: 'on_demand_only',
+        full_pack_injected: false,
+        reason: result.reason,
+        repair_command: CONTEXT_GRAPH_REPAIR_COMMAND,
+        snapshot_hash: result.snapshotHash,
+        snapshot_freshness: result.snapshotFreshness,
+        profile: result.available ? result.profile : null,
+        token_cost: result.tokenCost,
+        token_budget: result.tokenBudget
+    };
 }
-export function extractBoundedTriwikiAttention(value, limit = DEFAULT_TRIWIKI_ATTENTION_ANCHOR_LIMIT, query = '') {
+export function extractBoundedTriwikiAttention(value, limit = DEFAULT_TRIWIKI_ATTENTION_ANCHOR_LIMIT, _retiredQueryHint) {
     const pack = asRecord(value);
     const attention = asRecord(pack.attention);
     const anchorLimit = normalizeLimit(limit);
-    const hydrateHints = new Map();
-    const hydrateOrder = new Map();
-    for (const [index, row] of (Array.isArray(attention.hydrate_first) ? attention.hydrate_first : []).entries()) {
-        if (!Array.isArray(row))
-            continue;
-        const id = text(row[0]);
-        const hint = text(row[1]);
-        if (id && hint) {
-            hydrateHints.set(id, hint.slice(0, 240));
-            hydrateOrder.set(id, index);
-        }
+    const hints = new Map();
+    for (const row of rowsOf(attention.hydrate_first)) {
+        if (row.id && row.hydrate_hint)
+            hints.set(row.id, row.hydrate_hint.slice(0, 240));
     }
-    const useFirst = [];
-    for (const [index, row] of (Array.isArray(attention.use_first) ? attention.use_first : []).entries()) {
-        if (!Array.isArray(row))
-            continue;
-        const id = text(row[0]);
-        if (!id || useFirst.some((anchor) => anchor.id === id))
+    const anchors = [];
+    const seen = new Set();
+    for (const row of rowsOf(attention.use_first)) {
+        if (anchors.length >= anchorLimit)
+            break;
+        if (!row.id || seen.has(row.id))
             continue;
-        useFirst.push({
-            id,
-            claim_hash: text(row[1]) || null,
-            source_hash: text(row[2]) || null,
-            hydrate_hint: hydrateHints.get(id) || null,
-            order: index
-        });
+        seen.add(row.id);
+        anchors.push({ ...row, hydrate_hint: row.hydrate_hint ?? hints.get(row.id) ?? null });
     }
-    const anchors = selectAnchors(useFirst, hydrateHints, hydrateOrder, anchorLimit, query);
+    const tokenCost = anchors.reduce((sum, anchor) => sum + anchor.token_cost, 0);
     return {
         schema: BOUNDED_TRIWIKI_ATTENTION_SCHEMA,
-        source: '.sneakoscope/wiki/context-pack.json',
+        source: TRIWIKI_ATTENTION_PACK_SOURCE,
         available: anchors.length > 0,
         attention_mode: text(attention.mode) || null,
         anchor_limit: anchorLimit,
         anchors,
         hydration_policy: 'on_demand_only',
-        full_pack_injected: false
+        full_pack_injected: false,
+        reason: anchors.length > 0 ? null : 'context_graph_no_match',
+        repair_command: CONTEXT_GRAPH_REPAIR_COMMAND,
+        snapshot_hash: text(pack.snapshot_hash) || null,
+        snapshot_freshness: null,
+        profile: null,
+        token_cost: tokenCost,
+        token_budget: DEFAULT_TRIWIKI_ATTENTION_TOKEN_BUDGET
     };
 }
-function selectAnchors(useFirst, hydrateHints, hydrateOrder, limit, query) {
-    const tokens = attentionQueryTokens(query);
-    if (!tokens.length)
-        return useFirst.slice(0, limit).map(stripOrder);
-    const selected = [];
-    const seen = new Set();
-    for (const anchor of useFirst.slice(0, Math.min(3, limit))) {
-        selected.push(stripOrder(anchor));
-        seen.add(anchor.id);
-    }
-    const candidates = [];
-    for (const anchor of useFirst) {
-        if (seen.has(anchor.id))
-            continue;
-        candidates.push({
-            ...stripOrder(anchor),
-            score: attentionRelevance(anchor.id, anchor.hydrate_hint, tokens),
-            order: anchor.order,
-            priority: 0
-        });
-    }
-    for (const [id, hint] of hydrateHints.entries()) {
-        if (seen.has(id) || useFirst.some((anchor) => anchor.id === id))
-            continue;
-        const score = attentionRelevance(id, hint, tokens);
-        if (score <= 0)
-            continue;
-        candidates.push({
-            id,
-            claim_hash: null,
-            source_hash: null,
-            hydrate_hint: hint,
-            score,
-            order: hydrateOrder.get(id) ?? Number.MAX_SAFE_INTEGER,
-            priority: 1
-        });
-    }
-    candidates.sort((left, right) => right.score - left.score || left.priority - right.priority || left.order - right.order);
-    for (const candidate of candidates) {
-        if (selected.length >= limit)
-            break;
-        if (candidate.score <= 0 || seen.has(candidate.id))
-            continue;
-        selected.push(stripRank(candidate));
-        seen.add(candidate.id);
-    }
-    for (const anchor of useFirst) {
-        if (selected.length >= limit)
-            break;
-        if (seen.has(anchor.id))
-            continue;
-        selected.push(stripOrder(anchor));
-        seen.add(anchor.id);
-    }
-    return selected;
-}
-function attentionQueryTokens(value) {
-    const stop = new Set([
-        'and', 'the', 'for', 'with', 'from', 'into', 'this', 'that', 'sks', 'src', 'core',
-        '작업', '구현', '개선', '추가', '변경', '기능', '모든', '최대한'
-    ]);
-    return [...new Set(String(value || '')
-            .normalize('NFKC')
-            .toLowerCase()
-            .replace(/[^\p{L}\p{N}]+/gu, ' ')
-            .split(/\s+/)
-            .map((token) => token.trim())
-            .filter((token) => token.length >= 2 && !stop.has(token)))]
-        .slice(0, 64);
-}
-function attentionRelevance(id, hint, tokens) {
-    const haystack = `${id} ${hint || ''}`
-        .normalize('NFKC')
-        .toLowerCase()
-        .replace(/[^\p{L}\p{N}]+/gu, ' ');
-    const compact = haystack.replace(/\s+/g, '');
-    return tokens.reduce((score, token) => {
-        if (haystack.includes(token))
-            return score + (token.length >= 5 ? 4 : 3);
-        return compact.includes(token) ? score + 2 : score;
-    }, 0);
-}
-function stripOrder(anchor) {
+function toAnchor(anchor) {
     return {
         id: anchor.id,
         claim_hash: anchor.claim_hash,
         source_hash: anchor.source_hash,
-        hydrate_hint: anchor.hydrate_hint
+        hydrate_hint: anchor.hydrate_hint,
+        reason_path: anchor.reason_path,
+        trust_score: anchor.trust_score,
+        freshness: anchor.freshness,
+        token_cost: anchor.token_cost,
+        provenance: anchor.provenance.map((ref) => ({
+            path: ref.path,
+            ...(ref.line === undefined ? {} : { line: ref.line }),
+            hash: ref.hash
+        }))
     };
 }
-function stripRank(anchor) {
+function rowsOf(value) {
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    for (const raw of value) {
+        const row = Array.isArray(raw) ? tupleRow(raw) : objectRow(raw);
+        if (row)
+            out.push(row);
+    }
+    return out;
+}
+function tupleRow(row) {
+    const id = text(row[0]);
+    if (!id)
+        return null;
+    const second = text(row[1]);
+    const third = text(row[2]);
+    const isHydrateRow = row.length <= 2;
     return {
-        id: anchor.id,
-        claim_hash: anchor.claim_hash,
-        source_hash: anchor.source_hash,
-        hydrate_hint: anchor.hydrate_hint
+        id,
+        claim_hash: isHydrateRow ? null : second || null,
+        source_hash: isHydrateRow ? null : third || null,
+        hydrate_hint: isHydrateRow ? second || null : null,
+        reason_path: [],
+        trust_score: 0,
+        freshness: 'unknown',
+        token_cost: 0,
+        provenance: []
     };
 }
+function objectRow(raw) {
+    const row = asRecord(raw);
+    const id = text(row.id);
+    if (!id)
+        return null;
+    return {
+        id,
+        claim_hash: text(row.claim_hash) || null,
+        source_hash: text(row.source_hash) || null,
+        hydrate_hint: text(row.hydrate_hint) || null,
+        reason_path: Array.isArray(row.reason_path) ? row.reason_path.map(text).filter(Boolean) : [],
+        trust_score: number(row.trust_score),
+        freshness: freshnessOf(row.freshness),
+        token_cost: Math.max(0, Math.trunc(number(row.token_cost))),
+        provenance: provenanceOf(row.provenance)
+    };
+}
+function provenanceOf(value) {
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    for (const raw of value) {
+        const ref = asRecord(raw);
+        const refPath = text(ref.path);
+        const hash = text(ref.hash);
+        if (!refPath || !hash)
+            continue;
+        const line = number(ref.line);
+        out.push({ path: refPath, ...(line > 0 ? { line } : {}), hash });
+    }
+    return out;
+}
+function freshnessOf(value) {
+    return value === 'fresh' || value === 'stale' ? value : 'unknown';
+}
 function normalizeLimit(value) {
     const parsed = Number(value);
     if (!Number.isFinite(parsed))
         return DEFAULT_TRIWIKI_ATTENTION_ANCHOR_LIMIT;
-    return Math.max(1, Math.min(16, Math.floor(parsed)));
+    return Math.max(1, Math.min(MAX_TRIWIKI_ATTENTION_ANCHOR_LIMIT, Math.floor(parsed)));
+}
+function number(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : 0;
 }
 function text(value) {
     return typeof value === 'string' ? value.trim() : '';