sneakoscope 6.1.0 → 6.2.0

package/dist/core/subagents/thread-budget.js

@@ -0,0 +1,21 @@
+export const DEFAULT_NARUTO_MAX_THREADS = 12;
+export const HARD_NARUTO_MAX_THREADS = 32;
+export const DEFAULT_NARUTO_REQUESTED_SUBAGENTS = 2;
+export function resolveSubagentThreadBudget(input = {}) {
+    const requested = clamp(input.requested ?? input.independentSliceCount ?? DEFAULT_NARUTO_REQUESTED_SUBAGENTS, 1, HARD_NARUTO_MAX_THREADS);
+    const configured = clamp(input.configuredMaxThreads ?? DEFAULT_NARUTO_MAX_THREADS, 1, HARD_NARUTO_MAX_THREADS);
+    return {
+        requestedSubagents: requested,
+        maxThreads: configured,
+        firstWave: Math.min(requested, configured),
+        waveCount: Math.ceil(requested / configured),
+        maxDepth: 1
+    };
+}
+function clamp(value, minimum, maximum) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed))
+        return minimum;
+    return Math.max(minimum, Math.min(maximum, Math.floor(parsed)));
+}
+//# sourceMappingURL=thread-budget.js.map

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

@@ -0,0 +1,168 @@
+import path from 'node:path';
+import { readJson } from '../fsx.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 function extractBoundedTriwikiAttention(value, limit = DEFAULT_TRIWIKI_ATTENTION_ANCHOR_LIMIT, query = '') {
+    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 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))
+            continue;
+        useFirst.push({
+            id,
+            claim_hash: text(row[1]) || null,
+            source_hash: text(row[2]) || null,
+            hydrate_hint: hydrateHints.get(id) || null,
+            order: index
+        });
+    }
+    const anchors = selectAnchors(useFirst, hydrateHints, hydrateOrder, anchorLimit, query);
+    return {
+        schema: BOUNDED_TRIWIKI_ATTENTION_SCHEMA,
+        source: '.sneakoscope/wiki/context-pack.json',
+        available: anchors.length > 0,
+        attention_mode: text(attention.mode) || null,
+        anchor_limit: anchorLimit,
+        anchors,
+        hydration_policy: 'on_demand_only',
+        full_pack_injected: false
+    };
+}
+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();
+    // Keep the leading high-trust policy anchors, then spend the remaining
+    // budget on query-relevant use_first or hydrate-first candidates. Hydrate-
+    // only rows stay hints: workers must open the cited source before relying on
+    // them, so relevance improves without treating lower-trust summaries as fact.
+    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) {
+    return {
+        id: anchor.id,
+        claim_hash: anchor.claim_hash,
+        source_hash: anchor.source_hash,
+        hydrate_hint: anchor.hydrate_hint
+    };
+}
+function stripRank(anchor) {
+    return {
+        id: anchor.id,
+        claim_hash: anchor.claim_hash,
+        source_hash: anchor.source_hash,
+        hydrate_hint: anchor.hydrate_hint
+    };
+}
+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)));
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function text(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+//# sourceMappingURL=triwiki-attention.js.map

package/dist/core/super-search/runtime-helpers.js

@@ -3,7 +3,7 @@ import dns from 'node:dns/promises';
 import net from 'node:net';
 import { nowIso, sha256, writeTextAtomic } from '../fsx.js';
 import { evaluateRealEvidencePolicy } from '../verification/real-evidence-policy.js';
-import { classifyAuthority, isOfficialUrl, makeSource, sourceFromKnownUrl } from './source-records.js';
+import { classifyAuthority, independenceClusterForDomain, isOfficialUrl, makeSource, sourceFromKnownUrl } from './source-records.js';
 const DEFAULT_FETCH = globalThis.fetch;
 export function normalizeGenericSourceRows(raw, providerId, family, intent, tier) {
     const rows = Array.isArray(raw) ? raw : Array.isArray(raw?.results) ? raw.results : raw ? [raw] : [];
@@ -16,13 +16,45 @@ export function normalizeGenericSourceRows(raw, providerId, family, intent, tier
             title: String(row.title || row.name || `${providerId} result ${index + 1}`),
             url,
             snippet: String(row.snippet || row.summary || row.text || ''),
-            verdict: providerId === 'context7' ? 'verified_content' : 'weak_content',
+            verdict: 'weak_content',
             authority: tier,
             primary: providerId === 'context7',
             path: [providerId]
         });
     });
 }
+export async function materializeContext7SourceRows(raw, artifactDir, intent) {
+    const rows = Array.isArray(raw) ? raw : Array.isArray(raw?.results) ? raw.results : raw ? [raw] : [];
+    const out = [];
+    for (let index = 0; index < rows.length; index += 1) {
+        const row = rows[index];
+        const url = typeof row?.url === 'string' ? row.url : typeof row?.link === 'string' ? row.link : null;
+        const content = String(row?.content || row?.full_text || row?.document || row?.markdown || row?.text || row?.snippet || '');
+        const visible = visibleEvidenceText(content);
+        const meaningful = visible.length >= 80 && (visible.match(/[\p{L}\p{N}]{2,}/gu) || []).length >= 8;
+        const contentSha = meaningful ? sha256(content) : null;
+        const contentArtifact = contentSha ? path.join('context7-content', `${contentSha.slice(0, 16)}.txt`) : null;
+        if (contentArtifact)
+            await writeTextAtomic(path.join(artifactDir, contentArtifact), content);
+        out.push(makeSource({
+            providerId: 'context7',
+            family: 'official_docs',
+            type: 'official_docs',
+            title: String(row?.title || row?.name || `context7 result ${index + 1}`),
+            url,
+            snippet: String(row?.snippet || row?.summary || visible.slice(0, 500)),
+            verdict: meaningful ? 'verified_content' : 'weak_content',
+            authority: 'A0',
+            primary: true,
+            path: ['context7', ...(contentArtifact ? ['materialized_content'] : ['snippet_only'])],
+            blockers: contentArtifact ? [] : ['context7_content_artifact_missing'],
+            contentArtifact,
+            contentSha256: contentSha,
+            contentLength: meaningful ? content.length : null
+        }));
+    }
+    return out;
+}
 export function sourceFromWebRow(row, index, intent) {
     return makeSource({
         providerId: 'codex_web',
@@ -49,7 +81,19 @@ export async function sourceFromUrlFetch(url, artifactDir, intent, opts = {}) {
             warnings
         };
     }
-    const policyOpts = { ...opts, networkLookupRequired: fetchFn === DEFAULT_FETCH };
+    const fetchTimeoutMs = boundedOperationTimeout(10_000, opts.hardTimeoutMs, opts.deadlineEpochMs);
+    if (fetchTimeoutMs <= 0) {
+        blockers.push('direct_url_fetch_deadline_exceeded');
+        return {
+            source: { ...sourceFromKnownUrl(url, intent), blockers, warnings: ['url_parse_only'] },
+            blockers,
+            warnings
+        };
+    }
+    const policyOpts = {
+        ...(opts.allowLocal === undefined ? {} : { allowLocal: opts.allowLocal }),
+        networkLookupRequired: fetchFn === DEFAULT_FETCH
+    };
     const initialPolicy = await evaluateUrlFetchPolicy(url, policyOpts);
     if (!initialPolicy.ok) {
         blockers.push(...initialPolicy.blockers);
@@ -62,7 +106,7 @@ export async function sourceFromUrlFetch(url, artifactDir, intent, opts = {}) {
     }
     warnings.push(...initialPolicy.warnings);
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 10000);
+    const timer = setTimeout(() => controller.abort(), fetchTimeoutMs);
     try {
         let currentUrl = url;
         let response = null;
@@ -112,9 +156,11 @@ export async function sourceFromUrlFetch(url, artifactDir, intent, opts = {}) {
         warnings.push(...finalPolicy.warnings);
         if (!response.ok)
             blockers.push(`direct_url_fetch_http_${response.status}`);
-        if (!capped.trim())
-            blockers.push('direct_url_fetch_empty_content');
-        const contentSha = capped.trim() ? sha256(capped) : null;
+        const contentInspection = inspectHydratedContent(capped, response.headers.get('content-type'));
+        blockers.push(...contentInspection.blockers);
+        warnings.push(...contentInspection.warnings);
+        const verifiedContent = response.ok && contentInspection.ok;
+        const contentSha = verifiedContent ? sha256(capped) : null;
         const relArtifact = contentSha ? path.join('url-content', `${contentSha.slice(0, 16)}.txt`) : null;
         if (relArtifact)
             await writeTextAtomic(path.join(artifactDir, relArtifact), capped);
@@ -124,8 +170,8 @@ export async function sourceFromUrlFetch(url, artifactDir, intent, opts = {}) {
             type: 'known_url',
             title: normalizedUrl,
             url: normalizedUrl,
-            snippet: capped.replace(/\s+/g, ' ').trim().slice(0, 500),
-            verdict: response.ok && capped.trim() ? 'verified_content' : 'blocked',
+            snippet: contentInspection.visible_text.slice(0, 500),
+            verdict: verifiedContent ? 'verified_content' : 'blocked',
             authority: classifyAuthority(normalizedUrl),
             primary: isOfficialUrl(normalizedUrl),
             path: opts.allowLocal ? ['direct_url_fetch', 'allow_local'] : ['direct_url_fetch'],
@@ -133,7 +179,7 @@ export async function sourceFromUrlFetch(url, artifactDir, intent, opts = {}) {
             blockers,
             contentArtifact: relArtifact,
             contentSha256: contentSha,
-            contentLength: capped.length
+            contentLength: verifiedContent ? capped.length : null
         });
         return { source, blockers, warnings };
     }
@@ -151,6 +197,75 @@ export async function sourceFromUrlFetch(url, artifactDir, intent, opts = {}) {
         clearTimeout(timer);
     }
 }
+function boundedOperationTimeout(fallbackMs, hardTimeoutMs, deadlineEpochMs) {
+    const hard = Number(hardTimeoutMs);
+    const deadline = Number(deadlineEpochMs);
+    const remaining = Number.isFinite(deadline) && deadline > 0 ? Math.floor(deadline - Date.now()) : Number.POSITIVE_INFINITY;
+    if (remaining <= 0)
+        return 0;
+    return Math.max(1, Math.floor(Math.min(fallbackMs, Number.isFinite(hard) && hard > 0 ? hard : Number.POSITIVE_INFINITY, remaining)));
+}
+export function inspectHydratedContent(raw, contentTypeValue) {
+    const body = String(raw || '');
+    const contentType = String(contentTypeValue || '').split(';')[0].trim().toLowerCase();
+    const blockers = [];
+    const warnings = [];
+    if (contentType && !isTextualEvidenceContentType(contentType)) {
+        blockers.push(`direct_url_fetch_unsupported_content_type:${contentType}`);
+    }
+    const visibleText = visibleEvidenceText(body);
+    if (!body.trim())
+        blockers.push('direct_url_fetch_empty_content');
+    if (looksLikeAuthenticationOrChallenge(body, visibleText))
+        blockers.push('direct_url_fetch_auth_or_challenge_content');
+    if (looksLikeSoftError(body, visibleText))
+        blockers.push('direct_url_fetch_error_or_soft_404_content');
+    const tokens = visibleText.match(/[\p{L}\p{N}]{2,}/gu) || [];
+    if (visibleText.length < 80 || tokens.length < 8)
+        blockers.push('direct_url_fetch_non_meaningful_content');
+    if (!contentType)
+        blockers.push('direct_url_fetch_content_type_missing');
+    return {
+        ok: blockers.length === 0,
+        visible_text: visibleText,
+        blockers: [...new Set(blockers)],
+        warnings: [...new Set(warnings)]
+    };
+}
+function isTextualEvidenceContentType(contentType) {
+    return contentType.startsWith('text/')
+        || contentType === 'application/json'
+        || contentType === 'application/ld+json'
+        || contentType === 'application/xml'
+        || contentType === 'application/xhtml+xml'
+        || contentType.endsWith('+json')
+        || contentType.endsWith('+xml');
+}
+function visibleEvidenceText(body) {
+    return body
+        .replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, ' ')
+        .replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, ' ')
+        .replace(/<noscript\b[^>]*>[\s\S]*?<\/noscript>/gi, ' ')
+        .replace(/<svg\b[^>]*>[\s\S]*?<\/svg>/gi, ' ')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/&(?:nbsp|amp|quot|apos|lt|gt);/gi, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function looksLikeAuthenticationOrChallenge(body, visibleText) {
+    const prefix = `${body.slice(0, 12000)}\n${visibleText.slice(0, 2000)}`;
+    const structuralLogin = /<form\b[^>]*(?:login|signin|sign-in)|<input\b[^>]*type\s*=\s*["']?password/i.test(prefix);
+    const challenge = /\b(?:verify (?:that )?you are human|checking your browser|attention required|captcha|cloudflare ray id|bot (?:check|challenge|detection)|enable javascript and cookies to continue)\b/i.test(prefix);
+    const shortAuthenticationShell = visibleText.length < 1200
+        && /\b(?:sign in|log in|login required|authentication required|access denied|unauthorized)\b/i.test(prefix);
+    return structuralLogin || challenge || shortAuthenticationShell;
+}
+function looksLikeSoftError(body, visibleText) {
+    const prefix = `${body.slice(0, 8000)}\n${visibleText.slice(0, 1600)}`;
+    return /<title[^>]*>\s*(?:404|not found|page not found|error|service unavailable|internal server error|bad gateway)\b/i.test(prefix)
+        || /\b(?:404\s+(?:error|not found)|page not found|the page you (?:requested|are looking for) (?:was not found|does not exist)|this page (?:does not|doesn't) exist|soft 404|service unavailable|internal server error|bad gateway)\b/i.test(prefix)
+        || /(?:페이지를\s*찾을\s*수\s*없|요청한\s*페이지가\s*없|서비스를\s*사용할\s*수\s*없|내부\s*서버\s*오류)/i.test(prefix);
+}
 async function evaluateUrlFetchPolicy(rawUrl, opts) {
     if (opts.allowLocal === true)
         return { ok: true, blockers: [], warnings: ['local_fetch_explicitly_allowed'] };
@@ -228,15 +343,36 @@ export function buildXDiscoverySources(queries, intent) {
     }));
 }
 export function dedupeSources(sources) {
-    const seen = new Map();
-    return sources.map((source) => {
+    const clusters = new Map();
+    for (const source of sources) {
         const key = source.canonical_url || source.content_sha256 || source.source_id;
-        const cluster = seen.get(key);
-        if (cluster)
-            return { ...source, duplicate_cluster_id: cluster };
-        seen.set(key, source.source_id);
-        return { ...source, duplicate_cluster_id: source.source_id };
-    }).filter((source) => source.duplicate_cluster_id === source.source_id);
+        const rows = clusters.get(key) || [];
+        rows.push(source);
+        clusters.set(key, rows);
+    }
+    return [...clusters.values()].map((rows) => {
+        const ranked = [...rows].sort((a, b) => sourceRank(b) - sourceRank(a));
+        const selected = ranked[0];
+        return {
+            ...selected,
+            duplicate_cluster_id: selected.source_id,
+            acquisition_path: [...new Set(rows.flatMap((row) => row.acquisition_path || []))],
+            warnings: [...new Set(rows.flatMap((row) => row.warnings || []))],
+            blockers: selected.acquisition_verdict === 'verified_content'
+                ? []
+                : [...new Set(rows.flatMap((row) => row.blockers || []))]
+        };
+    });
+}
+function sourceRank(source) {
+    const verdict = source.acquisition_verdict === 'verified_content'
+        ? 5
+        : source.acquisition_verdict === 'partial_content'
+            ? 3
+            : source.acquisition_verdict === 'weak_content'
+                ? 2
+                : 0;
+    return verdict * 100 + source.trust_score * 10 + source.relevance_score;
 }
 export function buildLeads(sources, mode) {
     if (mode === 'fast')
@@ -318,12 +454,30 @@ export function buildProof(mode, intent, sources, claims, convergence, blockers,
     });
     proofBlockers.push(...realEvidencePolicy.blockers);
     warnings.push(...realEvidencePolicy.warnings);
+    const verifiedSources = sources.filter((source) => source.acquisition_verdict === 'verified_content');
+    const verifiedProviderIds = [...new Set(verifiedSources
+            .map((source) => String(source.provider_id || '').trim())
+            .filter(Boolean))];
+    const verifiedProviderFamilies = [...new Set(verifiedSources
+            .map((source) => String(source.source_family || '').trim().toLowerCase())
+            .filter(Boolean))];
+    const verifiedIndependenceClusters = [...new Set(verifiedSources
+            .map((source) => String(source.independence_cluster_id || independenceClusterForDomain(source.domain) || '').trim().toLowerCase())
+            .filter(Boolean))];
+    const providerIndependent = verifiedProviderFamilies.length >= 2 && verifiedIndependenceClusters.length >= 2;
     return {
         schema: 'sks.super-search-proof.v1',
         ok: proofBlockers.length === 0,
         mode,
         intent,
-        provider_independent: true,
+        provider_independent: providerIndependent,
+        provider_independence_basis: 'distinct_verified_provider_families_and_independence_clusters',
+        verified_provider_count: verifiedProviderIds.length,
+        verified_provider_ids: verifiedProviderIds,
+        verified_provider_family_count: verifiedProviderFamilies.length,
+        verified_provider_families: verifiedProviderFamilies,
+        verified_independence_cluster_count: verifiedIndependenceClusters.length,
+        verified_independence_clusters: verifiedIndependenceClusters,
         xai_runtime_dependency: false,
         snippet_only_final_claims: weakContentFinalClaims,
         weak_content_final_claims: weakContentFinalClaims,