sneakoscope 6.0.3 → 6.1.2

package/dist/core/team-review-policy.js

@@ -1,6 +1,21 @@
 export const MIN_TEAM_REVIEWER_LANES = 5;
 export const MIN_TEAM_REVIEW_STAGE_AGENT_SESSIONS = MIN_TEAM_REVIEWER_LANES;
 export const MIN_TEAM_REVIEW_POLICY_TEXT = `Minimum Team review policy: run at least ${MIN_TEAM_REVIEWER_LANES} independent reviewer/QA validation lanes before integration or final, even when the requested reviewer role count is lower.`;
+export const DEFAULT_OFFICIAL_REVIEWER_LANES = 1;
+export const MAX_AUTOMATIC_OFFICIAL_REVIEWER_LANES = 2;
+export const MAX_CRITICAL_OFFICIAL_REVIEWER_LANES = 3;
+export const OFFICIAL_SUBAGENT_REVIEW_POLICY_TEXT = 'Official subagent review policy: start with one focused reviewer, expand to two only for independent review domains, and use at most three automatic reviewers for critical multi-domain risk. The parent owns integration and may honor a larger explicit operator request.';
+export function officialSubagentReviewLaneBudget(input = {}) {
+    if (Number.isFinite(Number(input.explicit)) && Number(input.explicit) > 0) {
+        return { requested: Math.floor(Number(input.explicit)), source: 'explicit_operator' };
+    }
+    const domains = Math.max(0, Math.floor(Number(input.independentDomains || 0)));
+    const ceiling = input.critical === true ? MAX_CRITICAL_OFFICIAL_REVIEWER_LANES : MAX_AUTOMATIC_OFFICIAL_REVIEWER_LANES;
+    return {
+        requested: Math.max(DEFAULT_OFFICIAL_REVIEWER_LANES, Math.min(ceiling, domains || DEFAULT_OFFICIAL_REVIEWER_LANES)),
+        source: 'risk_scoped_automatic'
+    };
+}
 function numericCount(value, fallback = 0) {
     const number = Number(value);
     return Number.isFinite(number) ? Math.max(0, Math.floor(number)) : fallback;

package/dist/core/triwiki/code-pack.js

@@ -14,14 +14,20 @@ export function codePackPrevPath(root) {
     return path.join(codePackDir(root), 'code-pack.prev.json');
 }
 export function buildCodePack(root, index, tokenBudget = DEFAULT_CODE_PACK_TOKEN_BUDGET) {
+    const normalizedBudget = Number.isFinite(tokenBudget) && tokenBudget >= 0
+        ? Math.floor(tokenBudget)
+        : DEFAULT_CODE_PACK_TOKEN_BUDGET;
     const entries = [];
+    let totalTokenCost = 0;
     for (const card of index.modules) {
         const entry = buildEntryForModule(card);
         if (!entry)
             continue;
+        if (totalTokenCost + entry.token_cost > normalizedBudget)
+            continue;
         entries.push(entry);
+        totalTokenCost += entry.token_cost;
     }
-    const totalTokenCost = entries.reduce((sum, entry) => sum + entry.token_cost, 0);
     return {
         schema: CODE_PACK_SCHEMA,
         generated_at: nowIso(),
@@ -29,7 +35,7 @@ export function buildCodePack(root, index, tokenBudget = DEFAULT_CODE_PACK_TOKEN
         source_file_count: index.scanned_file_count,
         index_digest: computeIndexDigest(index),
         entries,
-        token_budget: tokenBudget,
+        token_budget: normalizedBudget,
         total_token_cost: totalTokenCost
     };
 }

package/dist/core/triwiki/triwiki-cache-key.js

@@ -9,7 +9,11 @@ const DEFAULT_EXCLUDED_DIRS = new Set([
     '.sneakoscope/reports',
     '.sneakoscope/missions',
     '.sneakoscope/quarantine',
-    'dist'
+    'dist',
+    '.claude',
+    '.cache',
+    'coverage',
+    'build'
 ]);
 export function computeTriWikiCacheKey(input) {
     const root = path.resolve(input.root);
@@ -69,7 +73,12 @@ export function collectInputFiles(root, patterns) {
             unsupported.push(`unsupported_brace_glob:${pattern}`);
             continue;
         }
-        const matches = expandInputPattern(root, pattern);
+        const normalized = normalizePattern(pattern);
+        if (!isSafeRelativePattern(root, normalized)) {
+            unsupported.push(`outside_root_or_unsafe_input:${pattern}`);
+            continue;
+        }
+        const matches = expandInputPattern(root, normalized);
         if (!matches.length) {
             const literal = path.resolve(root, pattern);
             if (fs.existsSync(literal))
@@ -87,44 +96,75 @@ export function collectInputFiles(root, patterns) {
         const hashed = hashPathIfPresent(root, rel);
         if (hashed.missing.length)
             missing.push(rel);
+        else if (hashed.unsupported?.length)
+            unsupported.push(...hashed.unsupported);
         else if (hashed.record)
             records.push(hashed.record);
     }
     return { records, missing: [...new Set(missing)].sort(), unsupported: [...new Set(unsupported)].sort() };
 }
-function expandInputPattern(root, pattern) {
-    const normalized = normalizePattern(pattern);
+function expandInputPattern(root, normalized) {
     if (!normalized.includes('*')) {
         const absolute = path.resolve(root, normalized);
-        if (!fs.existsSync(absolute))
+        if (!fs.existsSync(absolute) || !safeInputPath(root, absolute, true))
             return [];
         return listFiles(root, absolute);
     }
     const regex = globToRegex(normalized);
-    return listFiles(root, root).filter((rel) => regex.test(rel));
+    const prefix = staticGlobPrefix(normalized);
+    const start = path.resolve(root, prefix || '.');
+    if (!isWithinRoot(root, start) || !safeInputPath(root, start, false))
+        return [];
+    return listFiles(root, start).filter((rel) => regex.test(rel));
 }
 function normalizePattern(pattern) {
     return pattern.replace(/\\/g, '/').replace(/^\.\//, '');
 }
 function globToRegex(pattern) {
-    const escaped = pattern
-        .split('')
-        .map((char) => {
-        if (char === '*')
-            return '*';
-        return /[\\^$+?.()|{}[\]]/.test(char) ? `\\${char}` : char;
-    })
-        .join('');
-    const regex = escaped
-        .replace(/\*\*\//g, '(?:.*/)?')
-        .replace(/\*\*/g, '.*')
-        .replace(/\*/g, '[^/]*');
-    return new RegExp(`^${regex}$`);
+    let regex = '^';
+    for (let index = 0; index < pattern.length; index += 1) {
+        const char = pattern[index] || '';
+        if (char === '*' && pattern[index + 1] === '*') {
+            if (pattern[index + 2] === '/') {
+                regex += '(?:.*/)?';
+                index += 2;
+            }
+            else {
+                regex += '.*';
+                index += 1;
+            }
+            continue;
+        }
+        if (char === '*') {
+            regex += '[^/]*';
+            continue;
+        }
+        regex += /[\\^$+?.()|{}[\]]/.test(char) ? `\\${char}` : char;
+    }
+    return new RegExp(`${regex}$`);
+}
+function staticGlobPrefix(pattern) {
+    const segments = pattern.split('/');
+    const fixed = segments.slice(0, segments.findIndex((segment) => segment.includes('*')) < 0
+        ? segments.length
+        : segments.findIndex((segment) => segment.includes('*')));
+    return fixed.join('/');
+}
+function isSafeRelativePattern(root, pattern) {
+    if (!pattern || path.isAbsolute(pattern) || pattern === '..' || pattern.startsWith('../'))
+        return false;
+    return isWithinRoot(root, path.resolve(root, pattern.replace(/\*.*$/, '')));
+}
+function isWithinRoot(root, candidate) {
+    const relative = path.relative(path.resolve(root), path.resolve(candidate));
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
 }
 function listFiles(root, start) {
     const out = [];
     if (!fs.existsSync(start))
         return out;
+    if (!safeInputPath(root, start, true))
+        return out;
     let stat;
     try {
         stat = fs.lstatSync(start);
@@ -174,6 +214,9 @@ function isMissingOrInaccessible(error) {
     return code === 'ENOENT' || code === 'EACCES' || code === 'ENOTDIR' || code === 'EPERM';
 }
 function isExcluded(rel) {
+    const segments = normalizePattern(rel).split('/');
+    if (segments.some((segment) => segment === 'node_modules' || segment === '.git' || segment === '.claude' || segment === '.cache'))
+        return true;
     for (const dir of DEFAULT_EXCLUDED_DIRS) {
         if (rel === dir || rel.startsWith(`${dir}/`))
             return true;
@@ -182,8 +225,12 @@ function isExcluded(rel) {
 }
 function hashPathIfPresent(root, rel) {
     const absolute = path.resolve(root, rel);
+    if (!isWithinRoot(root, absolute))
+        return { hash: 'unsupported', missing: [], unsupported: [`outside_root:${rel}`] };
     if (!fs.existsSync(absolute))
         return { hash: 'missing', missing: [rel] };
+    if (!safeInputPath(root, absolute, true))
+        return { hash: 'unsupported', missing: [], unsupported: [`symlink_escape_or_unsafe_input:${rel}`] };
     const stat = fs.lstatSync(absolute);
     const mode = stat.isSymbolicLink() ? 'symlink' : stat.isDirectory() ? 'dir' : 'file';
     if (stat.isDirectory()) {
@@ -198,25 +245,57 @@ function hashPathIfPresent(root, rel) {
         const hash = hashJson({ rel, target, mode, outside_root: outsideRoot });
         return { hash, missing: [], record: { path: normalizePattern(rel), hash, size: target.length, mode } };
     }
+    if (!stat.isFile())
+        return { hash: 'unsupported', missing: [], unsupported: [`non_regular_input:${rel}`] };
     const hash = hashFileChunked(absolute, stat.size);
     return { hash, missing: [], record: { path: normalizePattern(rel), hash, size: stat.size, mode } };
 }
+function safeInputPath(root, candidate, allowFinalSymlink) {
+    const resolvedRoot = path.resolve(root);
+    const resolvedCandidate = path.resolve(candidate);
+    if (!isWithinRoot(resolvedRoot, resolvedCandidate))
+        return false;
+    const relative = path.relative(resolvedRoot, resolvedCandidate);
+    const segments = relative ? relative.split(path.sep).filter(Boolean) : [];
+    let cursor = resolvedRoot;
+    for (let index = 0; index < segments.length; index += 1) {
+        cursor = path.join(cursor, segments[index]);
+        let stat;
+        try {
+            stat = fs.lstatSync(cursor);
+        }
+        catch (error) {
+            return false;
+        }
+        if (stat.isSymbolicLink() && !(allowFinalSymlink && index === segments.length - 1))
+            return false;
+    }
+    try {
+        const finalStat = fs.lstatSync(resolvedCandidate);
+        if (finalStat.isSymbolicLink() && allowFinalSymlink)
+            return true;
+        const realRoot = fs.realpathSync(resolvedRoot);
+        const realCandidate = fs.realpathSync(resolvedCandidate);
+        return isWithinRoot(realRoot, realCandidate);
+    }
+    catch (error) {
+        return false;
+    }
+}
 function hashFileChunked(file, size) {
     const h = crypto.createHash('sha256');
     h.update(`size:${size}:`);
     const chunk = 256 * 1024;
     const fd = fs.openSync(file, 'r');
     try {
-        if (size <= chunk * 3) {
-            h.update(fs.readFileSync(file));
-        }
-        else {
-            for (const offset of [0, Math.max(0, Math.floor(size / 2) - Math.floor(chunk / 2)), Math.max(0, size - chunk)]) {
-                const buffer = Buffer.alloc(chunk);
-                const read = fs.readSync(fd, buffer, 0, chunk, offset);
-                h.update(`@${offset}:`);
-                h.update(buffer.subarray(0, read));
-            }
+        const buffer = Buffer.allocUnsafe(chunk);
+        let offset = 0;
+        while (offset < size) {
+            const read = fs.readSync(fd, buffer, 0, Math.min(buffer.length, size - offset), offset);
+            if (read <= 0)
+                break;
+            h.update(buffer.subarray(0, read));
+            offset += read;
         }
     }
     finally {

package/dist/core/triwiki/triwiki-module-card.js

@@ -14,7 +14,7 @@ export const DEFAULT_TRIWIKI_MODULE_CARDS = [
     moduleCard('doctor-dirty-repair', ['src/core/doctor/doctor-dirty-planner.ts', 'src/core/doctor/doctor-repair-postcheck.ts', 'src/scripts/doctor-dirty-*.ts'], ['doctor:dirty'], ['doctor-production'], 'high'),
     moduleCard('startup-config-repair', ['src/core/doctor/*startup*.ts', 'src/scripts/doctor-startup-*.ts'], ['doctor:startup'], ['doctor-production'], 'high'),
     moduleCard('context7-mcp', ['src/core/doctor/*context7*.ts', 'src/commands/context7.ts'], ['doctor:context7', 'context7:'], ['startup-mcp'], 'critical'),
-    moduleCard('supabase-mcp', ['src/core/doctor/*supabase*.ts', 'src/commands/db.ts'], ['doctor:supabase', 'db:'], ['startup-mcp'], 'critical'),
+    moduleCard('supabase-mcp', ['src/core/doctor/*supabase*.ts', 'src/core/db-safety.ts', 'src/core/pipeline-internals/runtime-core.ts'], ['doctor:supabase', 'mad-db:', 'mad-sks:'], ['startup-mcp'], 'critical'),
     moduleCard('native-capability', ['src/core/codex-native/**', 'src/scripts/native-*.ts'], ['native:', 'codex-native:'], ['native-capability'], 'high'),
     moduleCard('secret-preservation', ['src/core/**/secret*.ts', 'src/scripts/secret-*.ts', 'safety-mutation-allowlist.json'], ['secret:', 'supabase-secret'], ['doctor-production'], 'critical'),
     moduleCard('core-skill', ['.agents/skills/**', 'src/scripts/core-skill-*.ts'], ['core-skill:'], ['core-skill'], 'high'),

package/dist/core/triwiki-attention.js

@@ -229,8 +229,10 @@ function uniqueAttentionRows(rows = [], max = 4) {
  * independent of the policy-claim RGBA/geometric selection above: code entries carry
  * no meaningful mission-coordinate proximity, so competing them against policy claims
  * for the same fixed slot budget would make their appearance arbitrary. Each surviving
- * entry becomes a use_first row (bare id, no fabricated RGBA) plus a hydrate_first row
- * pointing at its source citations, so a consumer knows which real files back it. */
+ * high-trust, clean entry becomes a use_first row (bare id, no fabricated RGBA).
+ * Lower-trust or wrongness-linked entries are hydrate-only so negative evidence can
+ * never be promoted into the high-trust fast path. Citation-backed hydrate rows tell
+ * consumers which real files must be read before relying on a summary. */
 function codePackAttentionRows(codePackEntries = [], tokenBudget = 2000, wrongnessByModule = {}) {
     const moduleWrongness = (entryId) => Number(wrongnessByModule[String(entryId || '').replace(/^code:/, '')] || 0);
     const sorted = [...(codePackEntries || [])]
@@ -245,13 +247,18 @@ function codePackAttentionRows(codePackEntries = [], tokenBudget = 2000, wrongne
         if (tokens + cost > tokenBudget)
             continue;
         tokens += cost;
-        useFirst.push([entry.id, null, null]);
         const citationPaths = Array.isArray(entry.citations) ? entry.citations.map((c) => c?.path).filter(Boolean) : [];
         const citationReason = citationPaths.length ? `code_citations:${citationPaths.join(',')}` : null;
         const wrongCount = moduleWrongness(entry.id);
-        // A module with past wrongness earns a hydrate row even without citations, tagged
-        // with a wrongness:<count> signal so a consumer re-reads it before trusting recall.
-        const reason = wrongCount > 0 ? `wrongness:${wrongCount}${citationReason ? `;${citationReason}` : ''}` : citationReason;
+        const action = trustAction(entry);
+        if (action === 'use' && wrongCount === 0)
+            useFirst.push([entry.id, null, null]);
+        const reasons = [
+            wrongCount > 0 ? `wrongness:${wrongCount}` : null,
+            action !== 'use' ? `trust_action:${action}` : null,
+            citationReason
+        ].filter(Boolean);
+        const reason = reasons.join(';');
         if (reason)
             hydrateFirst.push([entry.id, reason]);
     }

package/dist/core/triwiki-provenance.js

@@ -0,0 +1,274 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { PACKAGE_VERSION, nowIso, sha256 } from './fsx.js';
+export const TRIWIKI_CONTEXT_PACK_PROVENANCE_SCHEMA = 'sks.triwiki-context-pack-provenance.v1';
+export const TRIWIKI_SOURCE_MANIFEST_SCHEMA = 'sks.triwiki-source-manifest.v1';
+const SOURCE_MANIFEST_MAX_FILES = 512;
+const SOURCE_MANIFEST_MAX_BYTES = 8 * 1024 * 1024;
+const DYNAMIC_SOURCE_PREFIXES = Object.freeze([
+    '.git',
+    'node_modules',
+    'dist',
+    '.sneakoscope/missions',
+    '.sneakoscope/reports',
+    '.sneakoscope/wiki',
+    '.sneakoscope/cache',
+    '.sneakoscope/tmp',
+    '.sneakoscope/locks',
+    '.sneakoscope/agents'
+]);
+function canonicalJson(value) {
+    if (value === null)
+        return 'null';
+    if (typeof value !== 'object')
+        return JSON.stringify(value) ?? 'null';
+    if (typeof value.toJSON === 'function')
+        return canonicalJson(value.toJSON());
+    if (Array.isArray(value))
+        return `[${value.map((entry) => canonicalJson(entry)).join(',')}]`;
+    const record = value;
+    return `{${Object.keys(record)
+        .filter((key) => record[key] !== undefined && typeof record[key] !== 'function' && typeof record[key] !== 'symbol')
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`)
+        .join(',')}}`;
+}
+function normalizedRelativePath(value) {
+    return value.split(path.sep).join('/').replace(/^\.\//, '').replace(/\/$/, '') || '.';
+}
+function pathIsInside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+}
+function isDynamicSourcePath(relativePath) {
+    const normalized = normalizedRelativePath(relativePath);
+    return DYNAMIC_SOURCE_PREFIXES.some((prefix) => normalized === prefix || normalized.startsWith(`${prefix}/`));
+}
+function authoritativeCitations(pack) {
+    const anchorValues = Array.isArray(pack?.wiki?.a)
+        ? pack.wiki.a.map((row) => row?.[8])
+        : (Array.isArray(pack?.wiki?.anchors) ? pack.wiki.anchors.map((anchor) => anchor?.p) : []);
+    const claimValues = (Array.isArray(pack?.claims) ? pack.claims : [])
+        .flatMap((claim) => Array.isArray(claim?.source_paths) ? claim.source_paths : []);
+    const values = [...anchorValues, ...claimValues];
+    const normalized = values
+        .filter((value) => typeof value === 'string' && value.trim())
+        .map((value) => value.trim());
+    return [...new Set(normalized)].sort((a, b) => a.localeCompare(b));
+}
+/**
+ * Bounded byte manifest for the exact local hydration citations carried by a
+ * context pack. Runtime/generated state is intentionally excluded so ordinary
+ * mission/report churn cannot invalidate otherwise-current source memory.
+ */
+export function buildTriWikiSourceManifest(pack, root) {
+    const citations = authoritativeCitations(pack);
+    const includedCitations = [];
+    const excludedDynamicCitations = [];
+    const roots = [];
+    const links = [];
+    const entries = [];
+    const blockers = [];
+    const resolvedRoot = root ? path.resolve(root) : '';
+    let realRoot = '';
+    try {
+        realRoot = resolvedRoot ? fs.realpathSync(resolvedRoot) : '';
+    }
+    catch { }
+    let totalBytes = 0;
+    const seenRealDirectories = new Set();
+    const seenEntryPaths = new Set();
+    const addBlocker = (value) => {
+        if (!blockers.includes(value))
+            blockers.push(value);
+    };
+    const walk = (absolute, displayPath) => {
+        let lstat;
+        let real;
+        try {
+            lstat = fs.lstatSync(absolute);
+            real = fs.realpathSync(absolute);
+        }
+        catch {
+            addBlocker(`source_manifest_path_unreadable:${displayPath}`);
+            return;
+        }
+        if (!pathIsInside(realRoot, real)) {
+            addBlocker(`source_manifest_path_outside_root:${displayPath}`);
+            return;
+        }
+        let stat = lstat;
+        if (lstat.isSymbolicLink()) {
+            links.push({ path: displayPath, target: normalizedRelativePath(path.relative(realRoot, real)) });
+            try {
+                stat = fs.statSync(absolute);
+            }
+            catch {
+                addBlocker(`source_manifest_path_unreadable:${displayPath}`);
+                return;
+            }
+        }
+        if (stat.isDirectory()) {
+            if (seenRealDirectories.has(real))
+                return;
+            seenRealDirectories.add(real);
+            let children;
+            try {
+                children = fs.readdirSync(absolute, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+            }
+            catch {
+                addBlocker(`source_manifest_path_unreadable:${displayPath}`);
+                return;
+            }
+            for (const child of children) {
+                const childDisplay = normalizedRelativePath(path.posix.join(displayPath, child.name));
+                if (isDynamicSourcePath(childDisplay))
+                    continue;
+                walk(path.join(absolute, child.name), childDisplay);
+                if (blockers.includes('source_manifest_file_limit_exceeded') || blockers.includes('source_manifest_byte_limit_exceeded'))
+                    return;
+            }
+            return;
+        }
+        if (!stat.isFile())
+            return;
+        if (seenEntryPaths.has(displayPath))
+            return;
+        if (entries.length >= SOURCE_MANIFEST_MAX_FILES) {
+            addBlocker('source_manifest_file_limit_exceeded');
+            return;
+        }
+        if (totalBytes + stat.size > SOURCE_MANIFEST_MAX_BYTES) {
+            addBlocker('source_manifest_byte_limit_exceeded');
+            return;
+        }
+        let bytes;
+        try {
+            bytes = fs.readFileSync(absolute);
+        }
+        catch {
+            addBlocker(`source_manifest_path_unreadable:${displayPath}`);
+            return;
+        }
+        totalBytes += bytes.length;
+        seenEntryPaths.add(displayPath);
+        entries.push({ path: displayPath, bytes: bytes.length, sha256: sha256(bytes) });
+    };
+    if (!realRoot)
+        addBlocker('source_manifest_root_missing');
+    for (const citation of citations) {
+        if (!realRoot)
+            break;
+        if (/^[a-z][a-z0-9+.-]*:\/\//i.test(citation)) {
+            addBlocker(`source_manifest_remote_citation_unbound:${citation}`);
+            continue;
+        }
+        const absolute = path.isAbsolute(citation) ? path.resolve(citation) : path.resolve(resolvedRoot, citation);
+        const relative = normalizedRelativePath(path.relative(resolvedRoot, absolute));
+        if (!pathIsInside(resolvedRoot, absolute)) {
+            addBlocker(`source_manifest_path_outside_root:${citation}`);
+            continue;
+        }
+        if (isDynamicSourcePath(relative)) {
+            excludedDynamicCitations.push(relative);
+            continue;
+        }
+        includedCitations.push(relative);
+        let stat;
+        try {
+            stat = fs.statSync(absolute);
+        }
+        catch {
+            addBlocker(`source_manifest_path_unreadable:${relative}`);
+            continue;
+        }
+        roots.push({ path: relative, kind: stat.isDirectory() ? 'directory' : 'file' });
+        walk(absolute, relative);
+    }
+    roots.sort((a, b) => a.path.localeCompare(b.path));
+    links.sort((a, b) => a.path.localeCompare(b.path));
+    entries.sort((a, b) => a.path.localeCompare(b.path));
+    blockers.sort((a, b) => a.localeCompare(b));
+    return {
+        schema: TRIWIKI_SOURCE_MANIFEST_SCHEMA,
+        scope: 'authoritative_citation_bytes',
+        root_binding: 'project_relative',
+        limits: { max_files: SOURCE_MANIFEST_MAX_FILES, max_total_bytes: SOURCE_MANIFEST_MAX_BYTES },
+        excluded_dynamic_prefixes: [...DYNAMIC_SOURCE_PREFIXES],
+        citations: includedCitations.sort((a, b) => a.localeCompare(b)),
+        excluded_dynamic_citations: excludedDynamicCitations.sort((a, b) => a.localeCompare(b)),
+        roots,
+        links,
+        entries,
+        file_count: entries.length,
+        total_bytes: totalBytes,
+        complete: blockers.length === 0,
+        blockers
+    };
+}
+export function triWikiSourceSnapshotId(sourceManifest) {
+    return sha256(canonicalJson(sourceManifest));
+}
+export function triWikiPayloadSha256(pack) {
+    const provenance = pack?.provenance && typeof pack.provenance === 'object'
+        ? { ...pack.provenance }
+        : {};
+    delete provenance.payload_sha256;
+    return sha256(canonicalJson({ ...pack, provenance }));
+}
+export function sealTriWikiContextPack(pack, options = {}) {
+    const { provenance: _priorProvenance, ...payload } = pack || {};
+    const sourceManifest = buildTriWikiSourceManifest(payload, options.root);
+    const provenance = {
+        schema: TRIWIKI_CONTEXT_PACK_PROVENANCE_SCHEMA,
+        generated_at: options.generatedAt || nowIso(),
+        package_snapshot_id: `sneakoscope@${options.packageVersion || PACKAGE_VERSION}`,
+        source_snapshot_id: triWikiSourceSnapshotId(sourceManifest),
+        source_manifest: sourceManifest
+    };
+    const sealed = { ...payload, provenance };
+    provenance.payload_sha256 = triWikiPayloadSha256(sealed);
+    return sealed;
+}
+export function validateTriWikiContextPackProvenance(pack, options = {}) {
+    const issues = [];
+    const provenance = pack?.provenance;
+    if (!provenance || typeof provenance !== 'object') {
+        issues.push({ id: 'context_pack_provenance_missing', severity: 'error' });
+        return { ok: false, issues };
+    }
+    if (provenance.schema !== TRIWIKI_CONTEXT_PACK_PROVENANCE_SCHEMA) {
+        issues.push({ id: 'context_pack_provenance_schema', severity: 'error' });
+    }
+    const generatedAt = String(provenance.generated_at || '');
+    if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/.test(generatedAt) || !Number.isFinite(Date.parse(generatedAt))) {
+        issues.push({ id: 'context_pack_generated_at', severity: 'error' });
+    }
+    const expectedPackage = `sneakoscope@${options.packageVersion || PACKAGE_VERSION}`;
+    if (provenance.package_snapshot_id !== expectedPackage) {
+        issues.push({ id: 'context_pack_package_snapshot_mismatch', severity: 'error' });
+    }
+    const sourceManifest = provenance.source_manifest;
+    if (!sourceManifest || sourceManifest.schema !== TRIWIKI_SOURCE_MANIFEST_SCHEMA || sourceManifest.scope !== 'authoritative_citation_bytes') {
+        issues.push({ id: 'context_pack_source_manifest_missing', severity: 'error' });
+    }
+    if (sourceManifest?.complete !== true || !Array.isArray(sourceManifest?.blockers) || sourceManifest.blockers.length) {
+        issues.push({ id: 'context_pack_source_manifest_incomplete', severity: 'error' });
+    }
+    const storedSource = sourceManifest ? triWikiSourceSnapshotId(sourceManifest) : '';
+    if (!/^[0-9a-f]{64}$/.test(String(provenance.source_snapshot_id || '')) || provenance.source_snapshot_id !== storedSource) {
+        issues.push({ id: 'context_pack_source_snapshot_mismatch', severity: 'error' });
+    }
+    const currentSourceManifest = buildTriWikiSourceManifest(pack, options.root);
+    if (!currentSourceManifest.complete)
+        issues.push({ id: 'context_pack_current_source_manifest_incomplete', severity: 'error' });
+    if (provenance.source_snapshot_id !== triWikiSourceSnapshotId(currentSourceManifest)) {
+        issues.push({ id: 'context_pack_source_bytes_mismatch', severity: 'error' });
+    }
+    const expectedPayload = triWikiPayloadSha256(pack);
+    if (!/^[0-9a-f]{64}$/.test(String(provenance.payload_sha256 || '')) || provenance.payload_sha256 !== expectedPayload) {
+        issues.push({ id: 'context_pack_payload_sha256_mismatch', severity: 'error' });
+    }
+    return { ok: issues.length === 0, issues };
+}
+//# sourceMappingURL=triwiki-provenance.js.map

package/dist/core/triwiki-runtime.js

@@ -1,13 +1,14 @@
 import path from 'node:path';
-import crypto from 'node:crypto';
 import { ensureDir, readJson, writeJsonAtomic } from './fsx.js';
+import { validateWikiCoordinateIndex } from './wiki-coordinate.js';
+import { validateTriWikiContextPackProvenance } from './triwiki-provenance.js';
 // Inference-path TriWiki consumption. Routes/the agent kernel READ the deployed
 // context pack written by `sks wiki refresh|pack` (the SSOT); they never rebuild
 // it on the hot path. This is the seam that turns the TriWiki engine from an
 // advisory prompt note into an actually-consulted, proof-referenced context source.
 export const TRIWIKI_CONTEXT_PACK_REL = '.sneakoscope/wiki/context-pack.json';
 export const TRIWIKI_RUNTIME_SCHEMA = 'sks.triwiki-runtime-context.v1';
-function emptyContext(file) {
+function emptyContext(file, warning = 'no_triwiki_context_pack (run `sks wiki refresh` to populate the project memory pack)') {
     return {
         schema: TRIWIKI_RUNTIME_SCHEMA,
         present: false,
@@ -19,7 +20,7 @@ function emptyContext(file) {
         claim_count: 0,
         anchor_count: 0,
         trust_avg: null,
-        warning: 'no_triwiki_context_pack (run `sks wiki refresh` to populate the project memory pack)'
+        warning
     };
 }
 /**
@@ -38,14 +39,27 @@ export async function loadTriWikiRuntimeContext(root) {
     }
     if (!pack || typeof pack !== 'object')
         return emptyContext(file);
-    const attention = pack.attention || {};
-    const wiki = pack.wiki || {};
+    const attention = pack.attention;
+    const wiki = pack.wiki;
+    if (!wiki || typeof wiki !== 'object') {
+        return emptyContext(file, 'invalid_triwiki_context_pack:wiki_index_missing (run `sks wiki refresh`)');
+    }
+    const coordinateValidation = validateWikiCoordinateIndex(wiki, { root, claims: pack.claims });
+    const provenanceValidation = validateTriWikiContextPackProvenance(pack, { root });
+    const issues = [...coordinateValidation.issues, ...provenanceValidation.issues];
+    if (issues.length) {
+        const issueIds = issues.map((issue) => String(issue.id || 'unknown')).slice(0, 8);
+        return emptyContext(file, `invalid_triwiki_context_pack:${issueIds.join(',')} (run \`sks wiki refresh\`)`);
+    }
+    if (!attention || !Array.isArray(attention.use_first) || !Array.isArray(attention.hydrate_first) || !Array.isArray(pack.claims)) {
+        return emptyContext(file, 'invalid_triwiki_context_pack:attention_or_claims_missing (run `sks wiki refresh`)');
+    }
     const anchorCount = Array.isArray(wiki.a) ? wiki.a.length : (Array.isArray(wiki.anchors) ? wiki.anchors.length : 0);
     return {
         schema: TRIWIKI_RUNTIME_SCHEMA,
         present: true,
         context_pack_path: file,
-        context_pack_hash: crypto.createHash('sha256').update(JSON.stringify(pack)).digest('hex'),
+        context_pack_hash: pack.provenance.payload_sha256,
         mission: typeof pack.mission === 'string' ? pack.mission : null,
         use_first: Array.isArray(attention.use_first) ? attention.use_first : [],
         hydrate_first: Array.isArray(attention.hydrate_first) ? attention.hydrate_first : [],
@@ -58,7 +72,7 @@ export async function loadTriWikiRuntimeContext(root) {
 /** Compact instruction block injected into read-only agents / route additionalContext. */
 export function triWikiContextBlock(ctx) {
     if (!ctx.present)
-        return 'TriWiki: no context pack present; run `sks wiki refresh` before relying on cached project memory.';
+        return `TriWiki unavailable: ${ctx.warning || 'context pack missing or invalid'}; do not rely on cached project memory.`;
     const ids = (rows) => rows.map((row) => (Array.isArray(row) ? row[0] : row?.id)).filter(Boolean).slice(0, 6);
     const use = ids(ctx.use_first);
     const hyd = ids(ctx.hydrate_first);