sneakoscope 6.0.3 → 6.1.2

package/dist/core/triwiki-wrongness/wrongness-ledger.js

@@ -1,34 +1,39 @@
+import fs from 'node:fs';
 import fsp from 'node:fs/promises';
 import path from 'node:path';
 import { ensureDir, exists, nowIso, readJson, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
-import { findLatestMission, missionDir, missionsDir } from '../mission.js';
+import { withFileLock } from '../locks/file-lock.js';
+import { findLatestMission, missionsDir } from '../mission.js';
 import { codexSchemaPath, runCodexExecResumeWithOutputSchema } from '../codex-exec-output-schema.js';
 import { WRONGNESS_INDEX_SCHEMA, WRONGNESS_LEDGER_SCHEMA, createWrongnessRecord, deterministicWrongnessId, emptyWrongnessLedger, normalizeRootCauseKind, normalizeSeverity, normalizeWrongnessKind, severityForRecord, validateWrongnessLedger } from './wrongness-schema.js';
+const CANONICAL_MISSION_ID_RE = /^M-[A-Za-z0-9][A-Za-z0-9._-]*$/;
 export function projectWrongnessLedgerPath(root) {
-    return path.join(root, '.sneakoscope', 'wiki', 'wrongness-ledger.json');
+    return path.join(safeWrongnessWikiDir(root), 'wrongness-ledger.json');
 }
 export function wrongnessIndexPath(root) {
-    return path.join(root, '.sneakoscope', 'wiki', 'wrongness-index.json');
+    return path.join(safeWrongnessWikiDir(root), 'wrongness-index.json');
 }
 export function wrongnessSummaryPath(root) {
-    return path.join(root, '.sneakoscope', 'wiki', 'wrongness-summary.md');
+    return path.join(safeWrongnessWikiDir(root), 'wrongness-summary.md');
 }
 export function missionWrongnessLedgerPath(root, missionId) {
-    return path.join(missionDir(root, missionId), 'wrongness-ledger.json');
+    return path.join(safeWrongnessMissionDir(root, missionId), 'wrongness-ledger.json');
 }
 export function missionWrongnessSummaryPath(root, missionId) {
-    return path.join(missionDir(root, missionId), 'wrongness-summary.md');
+    return path.join(safeWrongnessMissionDir(root, missionId), 'wrongness-summary.md');
 }
 export function missionWrongnessLinksPath(root, missionId) {
-    return path.join(missionDir(root, missionId), 'wrongness-triwiki-links.json');
+    return path.join(safeWrongnessMissionDir(root, missionId), 'wrongness-triwiki-links.json');
 }
 export async function resolveWrongnessMissionId(root, missionArg = null) {
     const raw = typeof missionArg === 'string' && missionArg.trim() ? missionArg.trim() : null;
     if (!raw || raw === 'project')
         return null;
-    if (raw === 'latest')
-        return findLatestMission(root);
-    return raw;
+    const resolved = raw === 'latest' ? await findLatestMission(root) : raw;
+    if (!resolved)
+        return null;
+    assertCanonicalMissionId(resolved);
+    return resolved;
 }
 export async function readWrongnessLedger(root, missionId = null) {
     const ledger = await readBaseWrongnessLedger(root, missionId);
@@ -48,6 +53,9 @@ async function readBaseWrongnessLedger(root, missionId = null) {
     return normalizeWrongnessLedger(raw, missionId ? 'mission' : 'project', missionId);
 }
 export async function writeWrongnessLedger(root, ledger) {
+    return withWrongnessMutationLock(root, () => writeWrongnessLedgerUnlocked(root, ledger));
+}
+async function writeWrongnessLedgerUnlocked(root, ledger) {
     const file = ledger.mission_id ? missionWrongnessLedgerPath(root, ledger.mission_id) : projectWrongnessLedgerPath(root);
     const normalized = normalizeWrongnessLedger({ ...ledger, generated_at: nowIso() }, ledger.scope, ledger.mission_id);
     await ensureDir(path.dirname(file));
@@ -57,7 +65,14 @@ export async function writeWrongnessLedger(root, ledger) {
 export async function readCombinedWrongnessRecords(root, missionId = null) {
     const project = await readWrongnessLedger(root, null);
     const mission = missionId ? await readWrongnessLedger(root, missionId) : emptyWrongnessLedger('mission', missionId);
-    return dedupeRecords([...project.records, ...mission.records]);
+    // The project ledger is also the cross-mission index, so it contains copies
+    // of mission-scoped records. A mission proof must inherit only truly global
+    // project records plus rows owned by that mission; otherwise unrelated old
+    // missions can block every future route forever.
+    const projectRecords = missionId
+        ? project.records.filter((record) => !record.mission_id || record.mission_id === missionId)
+        : project.records;
+    return dedupeRecords([...projectRecords, ...mission.records]);
 }
 export async function addWrongnessRecord(root, input = {}, opts = {}) {
     const row = asRecord(input);
@@ -66,11 +81,15 @@ export async function addWrongnessRecord(root, input = {}, opts = {}) {
         : typeof row.mission_id === 'string'
             ? row.mission_id
             : null;
+    if (missionId)
+        assertCanonicalMissionId(missionId);
     const record = createWrongnessRecord({ ...row, mission_id: missionId });
-    const project = await upsertIntoScope(root, null, record);
-    const mission = missionId ? await upsertIntoScope(root, missionId, record) : null;
-    await writeWrongnessSummaries(root, missionId);
-    return { record, project, mission };
+    return withWrongnessMutationLock(root, async () => {
+        const project = await upsertIntoScopeUnlocked(root, null, record);
+        const mission = missionId ? await upsertIntoScopeUnlocked(root, missionId, record) : null;
+        await writeWrongnessSummariesUnlocked(root, missionId);
+        return { record, project, mission };
+    });
 }
 export async function extractWrongnessWithOutputSchema(root, { sessionId, prompt, outputFile = null } = {}) {
     if (!sessionId) {
@@ -90,36 +109,47 @@ export async function extractWrongnessWithOutputSchema(root, { sessionId, prompt
     }, { cwd: root });
 }
 export async function resolveWrongnessRecord(root, id, reason = 'Resolved after corrective action', status = 'resolved') {
-    const scopes = await discoverWrongnessScopes(root);
-    const updatedRecords = [];
-    let updated = 0;
-    for (const missionId of scopes) {
-        const ledger = await readWrongnessLedger(root, missionId);
-        let changed = false;
-        const records = ledger.records.map((record) => {
-            if (record.id !== id)
-                return record;
-            changed = true;
-            updated += 1;
-            const next = {
-                ...record,
-                updated_at: nowIso(),
-                status,
-                truth_status: status === 'false_alarm' ? 'uncertain' : 'corrected',
-                corrective_action: {
-                    ...record.corrective_action,
-                    patch_status: status,
-                    summary: reason || record.corrective_action.summary
-                }
-            };
-            updatedRecords.push(next);
-            return next;
-        });
-        if (changed)
-            await writeWrongnessLedger(root, { ...ledger, records });
-    }
-    await writeWrongnessSummaries(root, null);
-    return { updated, records: updatedRecords };
+    return withWrongnessMutationLock(root, async () => {
+        const scopes = await discoverWrongnessScopes(root);
+        const updatedRecords = [];
+        const changedMissions = new Set();
+        let updated = 0;
+        for (const missionId of scopes) {
+            // Mutations must start from the writable base ledger. The project reader also
+            // overlays shared shards, and writing that combined view would duplicate every
+            // shared record into the project ledger.
+            const ledger = await readBaseWrongnessLedger(root, missionId);
+            let changed = false;
+            const records = ledger.records.map((record) => {
+                if (record.id !== id)
+                    return record;
+                changed = true;
+                updated += 1;
+                const next = {
+                    ...record,
+                    updated_at: nowIso(),
+                    status,
+                    truth_status: status === 'false_alarm' ? 'uncertain' : 'corrected',
+                    corrective_action: {
+                        ...record.corrective_action,
+                        patch_status: status,
+                        summary: reason || record.corrective_action.summary
+                    }
+                };
+                updatedRecords.push(next);
+                return next;
+            });
+            if (changed) {
+                await writeWrongnessLedgerUnlocked(root, { ...ledger, records });
+                if (missionId)
+                    changedMissions.add(missionId);
+            }
+        }
+        await writeWrongnessSummariesUnlocked(root, null);
+        for (const missionId of changedMissions)
+            await writeMissionWrongnessSummaryUnlocked(root, missionId);
+        return { updated, records: updatedRecords };
+    });
 }
 export async function findWrongnessRecord(root, id) {
     for (const missionId of await discoverWrongnessScopes(root)) {
@@ -169,20 +199,25 @@ export function summarizeWrongnessRecords(records) {
     };
 }
 export async function writeWrongnessSummaries(root, missionId = null) {
+    return withWrongnessMutationLock(root, () => writeWrongnessSummariesUnlocked(root, missionId));
+}
+async function writeWrongnessSummariesUnlocked(root, missionId = null) {
     await writeProjectWrongnessIndex(root);
     await writeTextAtomic(wrongnessSummaryPath(root), renderWrongnessSummaryMarkdown(await readWrongnessLedger(root, null), 'Project Wrongness Memory'));
-    if (missionId) {
-        const ledger = await readWrongnessLedger(root, missionId);
-        await writeTextAtomic(missionWrongnessSummaryPath(root, missionId), renderWrongnessSummaryMarkdown(ledger, `Mission ${missionId} Wrongness Memory`));
-        await writeJsonAtomic(missionWrongnessLinksPath(root, missionId), {
-            schema: 'sks.triwiki-wrongness-links.v1',
-            generated_at: nowIso(),
-            mission_id: missionId,
-            project_ledger: '.sneakoscope/wiki/wrongness-ledger.json',
-            mission_ledger: `.sneakoscope/missions/${missionId}/wrongness-ledger.json`,
-            active_ids: ledger.records.filter((record) => record.status === 'active').map((record) => record.id)
-        });
-    }
+    if (missionId)
+        await writeMissionWrongnessSummaryUnlocked(root, missionId);
+}
+async function writeMissionWrongnessSummaryUnlocked(root, missionId) {
+    const ledger = await readBaseWrongnessLedger(root, missionId);
+    await writeTextAtomic(missionWrongnessSummaryPath(root, missionId), renderWrongnessSummaryMarkdown(ledger, `Mission ${missionId} Wrongness Memory`));
+    await writeJsonAtomic(missionWrongnessLinksPath(root, missionId), {
+        schema: 'sks.triwiki-wrongness-links.v1',
+        generated_at: nowIso(),
+        mission_id: missionId,
+        project_ledger: '.sneakoscope/wiki/wrongness-ledger.json',
+        mission_ledger: `.sneakoscope/missions/${missionId}/wrongness-ledger.json`,
+        active_ids: ledger.records.filter((record) => record.status === 'active').map((record) => record.id)
+    });
 }
 export async function recordWrongnessFromTrustReport(root, report) {
     const row = asRecord(report);
@@ -263,7 +298,7 @@ export async function recordDbSafetyMismatchWrongness(root, input = {}) {
         wrongness_kind: kind,
         severity: kind === 'db_safety_false_negative' ? 'high' : 'medium',
         claim: { text: `DB safety expected ${expected} but classified ${actual}.` },
-        detected_by: { source: 'db_safety_check', command: typeof row.command === 'string' ? row.command : 'sks db check', artifact: typeof row.artifact === 'string' ? row.artifact : null, detail: typeof row.sql === 'string' ? row.sql : null },
+        detected_by: { source: 'db_safety_check', command: typeof row.command === 'string' ? row.command : '$DB internal safety check', artifact: typeof row.artifact === 'string' ? row.artifact : null, detail: typeof row.sql === 'string' ? row.sql : null },
         root_cause: { category: 'missing_db_policy', explanation: 'A DB safety expectation did not match the current classifier output.' },
         corrective_action: { summary: 'Adjust the policy/classifier or fixture expectation, then rerun DB safety validation.', required_evidence: ['db-operation-report.json'], patch_status: 'pending' },
         links: { artifacts: typeof row.artifact === 'string' ? [row.artifact] : [] }
@@ -319,10 +354,18 @@ function normalizeWrongnessLedger(value, scope, missionId) {
         records
     };
 }
-async function upsertIntoScope(root, missionId, record) {
+async function upsertIntoScopeUnlocked(root, missionId, record) {
     const ledger = await readBaseWrongnessLedger(root, missionId);
     const nextRecords = upsertRecord(ledger.records, record);
-    return writeWrongnessLedger(root, { ...ledger, records: nextRecords });
+    return writeWrongnessLedgerUnlocked(root, { ...ledger, records: nextRecords });
+}
+function withWrongnessMutationLock(root, fn) {
+    const lockDir = safeWrongnessLockDir(root);
+    return withFileLock({
+        lockPath: path.join(lockDir, 'triwiki-wrongness.lock'),
+        timeoutMs: 60_000,
+        staleMs: 120_000
+    }, fn);
 }
 function upsertRecord(records, record) {
     const seen = new Set();
@@ -355,13 +398,96 @@ async function discoverWrongnessScopes(root) {
         return scopes;
     }
     for (const name of entries) {
-        if (!name.startsWith('M-'))
+        if (!CANONICAL_MISSION_ID_RE.test(name))
             continue;
         if (await exists(missionWrongnessLedgerPath(root, name)))
             scopes.push(name);
     }
     return scopes;
 }
+function assertCanonicalMissionId(missionId) {
+    if (!CANONICAL_MISSION_ID_RE.test(String(missionId || '')))
+        throw new Error(`invalid_mission_id:${missionId}`);
+}
+function safeWrongnessMissionDir(root, missionId) {
+    assertCanonicalMissionId(missionId);
+    const resolvedRoot = path.resolve(root);
+    const stateRoot = assertSafeSneakoscopeRoot(resolvedRoot);
+    const base = path.resolve(missionsDir(resolvedRoot));
+    const candidate = path.resolve(base, missionId);
+    const relative = path.relative(base, candidate);
+    if (relative.startsWith('..') || path.isAbsolute(relative))
+        throw new Error(`mission_path_outside_root:${missionId}`);
+    const baseStat = lstatIfPresent(base);
+    if (baseStat && (!baseStat.isDirectory() || baseStat.isSymbolicLink()))
+        throw new Error('unsafe_missions_root_symlink');
+    const candidateStat = lstatIfPresent(candidate);
+    if (candidateStat && (!candidateStat.isDirectory() || candidateStat.isSymbolicLink()))
+        throw new Error(`unsafe_mission_directory:${missionId}`);
+    if (baseStat && candidateStat) {
+        const realBase = fs.realpathSync(base);
+        const realCandidate = fs.realpathSync(candidate);
+        const realRelative = path.relative(realBase, realCandidate);
+        if (realRelative.startsWith('..') || path.isAbsolute(realRelative))
+            throw new Error(`mission_realpath_outside_root:${missionId}`);
+    }
+    return candidate;
+}
+function safeWrongnessWikiDir(root) {
+    const stateRoot = assertSafeSneakoscopeRoot(root);
+    const wiki = path.join(stateRoot, 'wiki');
+    const wikiStat = lstatIfPresent(wiki);
+    if (wikiStat && (!wikiStat.isDirectory() || wikiStat.isSymbolicLink()))
+        throw new Error('unsafe_wrongness_wiki_symlink');
+    if (wikiStat) {
+        const realState = fs.realpathSync(stateRoot);
+        const realWiki = fs.realpathSync(wiki);
+        const relative = path.relative(realState, realWiki);
+        if (relative.startsWith('..') || path.isAbsolute(relative))
+            throw new Error('wrongness_wiki_realpath_outside_root');
+    }
+    return wiki;
+}
+function safeWrongnessLockDir(root) {
+    const stateRoot = assertSafeSneakoscopeRoot(root);
+    const locks = path.join(stateRoot, 'locks');
+    const lockStat = lstatIfPresent(locks);
+    if (lockStat && (!lockStat.isDirectory() || lockStat.isSymbolicLink()))
+        throw new Error('unsafe_wrongness_lock_symlink');
+    if (lockStat) {
+        const realState = fs.realpathSync(stateRoot);
+        const realLocks = fs.realpathSync(locks);
+        const relative = path.relative(realState, realLocks);
+        if (relative.startsWith('..') || path.isAbsolute(relative))
+            throw new Error('wrongness_lock_realpath_outside_root');
+    }
+    return locks;
+}
+function assertSafeSneakoscopeRoot(root) {
+    const resolvedRoot = path.resolve(root);
+    const stateRoot = path.join(resolvedRoot, '.sneakoscope');
+    const stateStat = lstatIfPresent(stateRoot);
+    if (stateStat && (!stateStat.isDirectory() || stateStat.isSymbolicLink()))
+        throw new Error('unsafe_sneakoscope_root_symlink');
+    if (stateStat) {
+        const realRoot = fs.realpathSync(resolvedRoot);
+        const realState = fs.realpathSync(stateRoot);
+        const relative = path.relative(realRoot, realState);
+        if (relative.startsWith('..') || path.isAbsolute(relative))
+            throw new Error('sneakoscope_realpath_outside_root');
+    }
+    return stateRoot;
+}
+function lstatIfPresent(file) {
+    try {
+        return fs.lstatSync(file);
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
 function dedupeRecords(records) {
     const byId = new Map();
     for (const record of records)

package/dist/core/triwiki-wrongness/wrongness-retrieval.js

@@ -8,15 +8,24 @@ export async function wrongnessContextForRoute(root, opts = {}) {
     const records = await readCombinedWrongnessRecords(root, missionId);
     const active = records.filter((record) => record.status === 'active');
     const routeRelevant = active.filter((record) => !route || !record.route || record.route === route || record.avoidance_rule.applies_to.includes(route));
-    const selected = [...routeRelevant, ...active.filter((record) => !routeRelevant.some((candidate) => candidate.id === record.id))]
+    const routeRelevantIds = new Set(routeRelevant.map((record) => record.id));
+    const selected = [...routeRelevant, ...active.filter((record) => !routeRelevantIds.has(record.id))]
         .sort(sortWrongnessForRecall)
         .slice(0, limit);
+    const summary = summarizeWrongnessRecords(records);
     return {
         schema: WRONGNESS_CONTEXT_SCHEMA,
         generated_at: nowIso(),
         mission_id: missionId,
         route,
-        summary: summarizeWrongnessRecords(records),
+        summary: {
+            ...summary,
+            active_ids: selected.map((record) => record.id),
+            avoidance_rules: selected.map((record) => record.avoidance_rule).filter((rule) => rule.text),
+            context_limit: limit,
+            omitted_active_records: Math.max(0, Number(summary.active || 0) - selected.length),
+            bounded: true
+        },
         active_records: selected.map(recordToContextRow),
         active_avoidance_rules: selected.map((record) => record.avoidance_rule),
         retrieval_policy: 'negative_evidence_first_for_related_claims; do not let active wrongness upgrade trust without correction evidence'

package/dist/core/triwiki-wrongness/wrongness-trust-policy.js

@@ -47,6 +47,8 @@ export function applyWrongnessTrustStatus(base, impact) {
         return 'failed';
     if (base === 'not_verified' || impactStatus === 'not_verified')
         return 'not_verified';
+    if (base === 'mock_only' || impactStatus === 'mock_only')
+        return 'mock_only';
     if (base === 'verified_partial' || impactStatus === 'verified_partial' || (impact.issues || []).length)
         return 'verified_partial';
     return 'verified';

package/dist/core/update-check.js

@@ -29,7 +29,7 @@ export async function runSksUpdateCheck(options = {}) {
         effectiveOptions.maxOutputBytes = options.maxOutputBytes;
     const override = env[versionOverrideEnvName(packageName)];
     const effectivePromise = detectEffectiveSksVersion(effectiveOptions);
-    const latestCache = !override ? await readUpdateLatestCache(packageName, registry).catch(() => null) : null;
+    const latestCache = !override ? await readUpdateLatestCache(packageName, registry, env).catch(() => null) : null;
     const latestPromise = !override && npmBin
         ? runProcess(npmBin, ['view', packageName, 'version', '--silent', '--registry', registry], {
             env,
@@ -92,7 +92,7 @@ export async function runSksUpdateCheck(options = {}) {
     }
     const latest = String(result.stdout || '').trim().split(/\s+/).pop() || null;
     if (latest)
-        await writeUpdateLatestCache(packageName, registry, latest).catch(() => undefined);
+        await writeUpdateLatestCache(packageName, registry, latest, env).catch(() => undefined);
     return buildResult({
         packageName,
         current,
@@ -107,7 +107,7 @@ export async function runSksUpdateNow(options = {}) {
     const registry = options.registry || DEFAULT_REGISTRY;
     const env = options.env || process.env;
     const npmBin = options.npmBin === undefined ? await which('npm') : options.npmBin;
-    const cwd = os.homedir();
+    const cwd = env.HOME || os.homedir();
     const check = await runSksUpdateCheck({
         ...options,
         packageName,
@@ -226,7 +226,7 @@ export async function runSksUpdateNow(options = {}) {
         const sksMenuBar = migrationCurrent
             ? await installUpdateSksMenuBar({ root: projectReceiptRoot, env, stage, quiet: machineOutput })
             : null;
-        await runUpdateGlobalSkillsReconcile(stage, { quiet: machineOutput });
+        await runUpdateGlobalSkillsReconcile(stage, { quiet: machineOutput, env });
         return buildUpdateNowResult({
             packageName,
             from: check.current,
@@ -337,9 +337,9 @@ export async function runSksUpdateNow(options = {}) {
             stage('new_version_probe', Boolean(newVersion), newVersion ? 'version_detected' : 'failed', { new_version: newVersion, code: versionProbe.code });
             stageStart('new_version_global_doctor', 'running migration doctor on updated install');
             newVersionDoctor = await updateHeartbeat(machineOutput, 'new-version doctor', runPackageLocalDoctor({
-                root: globalSksRootPath(),
+                root: globalSksRootPath(env),
                 entrypoint: newBinary,
-                args: ['doctor', '--fix', '--yes', '--profile', 'migration', '--machine-only', '--report-file', path.join(globalSksRootPath(), 'update', 'new-version-doctor.json')],
+                args: ['doctor', '--fix', '--yes', '--profile', 'migration', '--machine-only', '--report-file', path.join(globalSksRootPath(env), 'update', 'new-version-doctor.json')],
                 env,
                 timeoutMs: updateDoctorTimeoutMs(env),
                 maxOutputBytes: 32 * 1024
@@ -370,10 +370,12 @@ export async function runSksUpdateNow(options = {}) {
                 sksMenuBar = await installUpdateSksMenuBar({ root: projectReceiptRoot, env, stage, quiet: machineOutput, entrypoint: newBinary });
             await runUpdateGlobalSkillsReconcile(stage, {
                 quiet: machineOutput,
+                env,
                 newPackageRoot: newBinary ? path.resolve(path.dirname(newBinary), '..', '..') : null
             });
             await runUpdateNativeCapabilitySetup(stage, {
                 quiet: machineOutput,
+                env,
                 newPackageRoot: newBinary ? path.resolve(path.dirname(newBinary), '..', '..') : null,
                 root: projectReceiptRoot
             });
@@ -417,7 +419,7 @@ export async function runSksUpdateNow(options = {}) {
     });
 }
 async function runUpdateGlobalSkillsReconcile(stage, opts = {}) {
-    const targetDir = path.join(os.homedir(), '.agents', 'skills');
+    const targetDir = path.join(opts.env?.HOME || os.homedir(), '.agents', 'skills');
     // reconcileSkills stamps ~/.agents/skills/.sks-generated.json with the
     // PACKAGE_VERSION compiled into whichever module runs it. This function
     // executes inside the OLD (driver) binary, so after a real version install
@@ -433,6 +435,7 @@ async function runUpdateGlobalSkillsReconcile(stage, opts = {}) {
             'if (r && (r.ok === false || r.error)) process.exit(1);'
         ].join('\n');
         const work = runProcess(process.execPath, ['--input-type=module', '-e', script], {
+            env: opts.env || process.env,
             timeoutMs: 120_000,
             maxOutputBytes: 1024 * 1024
         }).catch((err) => ({ code: 1, stdout: '', stderr: err?.message || String(err) }));
@@ -489,6 +492,7 @@ async function runUpdateNativeCapabilitySetup(stage, opts) {
         'console.log(JSON.stringify({ imagegen, computer_use: computerUse, browser_use: browserUse }));'
     ].join('\n');
     const work = runProcess(process.execPath, ['--input-type=module', '-e', script], {
+        env: opts.env || process.env,
         timeoutMs: 180_000,
         maxOutputBytes: 1024 * 1024
     }).catch((err) => ({ code: 1, stdout: '', stderr: err?.message || String(err) }));
@@ -654,8 +658,8 @@ function buildResult(input) {
         error: input.error || null
     };
 }
-async function readUpdateLatestCache(packageName, registry) {
-    const file = updateLatestCachePath(packageName, registry);
+async function readUpdateLatestCache(packageName, registry, env) {
+    const file = updateLatestCachePath(packageName, registry, env);
     const text = await fs.readFile(file, 'utf8');
     const parsed = JSON.parse(text);
     if (parsed?.package !== packageName || parsed?.registry !== registry || !parsed?.latest || !parsed?.generated_at)
@@ -665,8 +669,8 @@ async function readUpdateLatestCache(packageName, registry) {
         return null;
     return { latest: String(parsed.latest) };
 }
-async function writeUpdateLatestCache(packageName, registry, latest) {
-    const file = updateLatestCachePath(packageName, registry);
+async function writeUpdateLatestCache(packageName, registry, latest, env) {
+    const file = updateLatestCachePath(packageName, registry, env);
     await fs.mkdir(path.dirname(file), { recursive: true });
     await fs.writeFile(file, `${JSON.stringify({
         schema: 'sks.update-check-cache.v1',
@@ -676,9 +680,11 @@ async function writeUpdateLatestCache(packageName, registry, latest) {
         latest
     }, null, 2)}\n`, 'utf8');
 }
-function updateLatestCachePath(packageName, registry) {
+function updateLatestCachePath(packageName, registry, env) {
     const safe = `${packageName}-${registry}`.replace(/[^a-z0-9._-]+/gi, '_').slice(0, 120);
-    return path.join(os.tmpdir(), 'sks-update-check-cache', `${safe}.json`);
+    const configuredRoot = String(env.SKS_UPDATE_CHECK_CACHE_ROOT || '').trim();
+    const cacheRoot = configuredRoot ? path.resolve(configuredRoot) : path.join(os.tmpdir(), 'sks-update-check-cache');
+    return path.join(cacheRoot, `${safe}.json`);
 }
 function buildUpdateNowResult(input) {
     return {
@@ -794,8 +800,10 @@ function parseVersionText(text) {
     const match = String(text || '').match(/\b\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?\b/);
     return match ? match[0] : null;
 }
-function globalSksRootPath() {
-    return path.join(process.env.HOME || os.homedir(), '.sneakoscope-global');
+function globalSksRootPath(env = process.env) {
+    if (env.SKS_GLOBAL_ROOT)
+        return path.resolve(env.SKS_GLOBAL_ROOT);
+    return path.join(env.HOME || os.homedir(), '.sneakoscope-global');
 }
 function updateDoctorTimeoutMs(env) {
     const override = Number.parseInt(env.SKS_UPDATE_NEW_DOCTOR_TIMEOUT_MS || env.SKS_MIGRATION_DOCTOR_TIMEOUT_MS || '', 10);

package/dist/core/version-manager.js

@@ -329,6 +329,14 @@ async function syncSourcePackageVersion(root, version) {
             rel: 'src/bin/sks.ts',
             replace: (text) => text.replace(/const FAST_PACKAGE_VERSION = ['"][^'"]+['"];/, `const FAST_PACKAGE_VERSION = '${version}';`)
         },
+        {
+            rel: 'src/core/managed-assets/managed-assets-manifest.ts',
+            replace: (text) => text.replace(/export const MANAGED_ASSET_VERSION = ['"][^'"]+['"]/, `export const MANAGED_ASSET_VERSION = '${version}'`)
+        },
+        {
+            rel: 'test/unit/agent-role-config.test.mjs',
+            replace: (text) => text.replace(/assert\.equal\(manifest\.MANAGED_ASSET_VERSION, ['"][^'"]+['"]\)/, `assert.equal(manifest.MANAGED_ASSET_VERSION, '${version}')`)
+        },
         {
             rel: 'crates/sks-core/Cargo.toml',
             replace: (text) => text.replace(/^version\s*=\s*"[^"]+"/m, `version = "${version}"`)
@@ -343,7 +351,49 @@ async function syncSourcePackageVersion(root, version) {
         },
         {
             rel: 'README.md',
-            replace: (text) => text.replace(/SKS \*\*\d+\.\d+\.\d+\*\*/, `SKS **${version}**`)
+            replace: (text) => text
+                .replace(/SKS \*\*\d+\.\d+\.\d+\*\*/, `SKS **${version}**`)
+                .replace(/^## Naruto In \d+\.\d+\.\d+$/m, `## Naruto In ${version}`)
+        },
+        {
+            rel: 'docs/release-readiness.md',
+            replace: (text) => text
+                .replace(/^SKS \d+\.\d+\.\d+ is ready/m, `SKS ${version} is ready`)
+                .replace(/^Codex 0\.142 references later in this document are historical release records and cannot authorize the \d+\.\d+\.\d+ release\./m, `Codex 0.142 references later in this document are historical release records and cannot authorize the ${version} release.`)
+                .replace(/^\d+\.\d+\.\d+ release readiness requires/m, `${version} release readiness requires`)
+                .replace(/^## Current publish authorization policy \(\d+\.\d+\.\d+\)$/m, `## Current publish authorization policy (${version})`)
+                .replace(/^The \d+\.\d+\.\d+ implementation handoff uses this bounded verification sequence:/m, `The ${version} implementation handoff uses this bounded verification sequence:`)
+                .replace(/^the \d+\.\d+\.\d+ command surface;/m, `the ${version} command surface;`)
+                .replace(/^not the \d+\.\d+\.\d+ release procedure\./m, `not the ${version} release procedure.`)
+                .replace(/do not satisfy the \d+\.\d+\.\d+ official-subagent gate\. Current \d+\.\d+\.\d+ proof/g, `do not satisfy the ${version} official-subagent gate. Current ${version} proof`)
+                .replace(/not represented as current \d+\.\d+\.\d+ completion proof\./g, `not represented as current ${version} completion proof.`)
+                .replace(/^For \d+\.\d+\.\d+, a selected codex-lb/m, `For ${version}, a selected codex-lb`)
+                .replace(/^The \d+\.\d+\.\d+ SKS menu bar/m, `The ${version} SKS menu bar`)
+        },
+        {
+            rel: 'docs/release-proof-truth.md',
+            replace: (text) => text
+                .replace(/^SKS \d+\.\d+\.\d+ release proof truth/m, `SKS ${version} release proof truth`)
+                .replace(/^SKS \d+\.\d+\.\d+ must not claim/m, `SKS ${version} must not claim`)
+                .replace(/cannot serve as \d+\.\d+\.\d+ evidence\./m, `cannot serve as ${version} evidence.`)
+        },
+        {
+            rel: 'docs/official-docs-compat.md',
+            replace: (text) => text
+                .replace(/^SKS \d+\.\d+\.\d+ keeps release-gated behavior/m, `SKS ${version} keeps release-gated behavior`)
+                .replace(/official-docs-compat-\d+\.\d+\.\d+\.(json|md)/g, `official-docs-compat-${version}.$1`)
+        },
+        {
+            rel: 'docs/codex-0.139-compat.md',
+            replace: (text) => text.replace(/^SKS \d+\.\d+\.\d+ keeps the historical/m, `SKS ${version} keeps the historical`)
+        },
+        {
+            rel: 'docs/codex-cli-compat.md',
+            replace: (text) => text.replace(/^SKS \d+\.\d+\.\d+ targets/m, `SKS ${version} targets`)
+        },
+        {
+            rel: 'docs/codex-app.md',
+            replace: (text) => text.replace(/^SKS \d+\.\d+\.\d+ targets/m, `SKS ${version} targets`)
         }
     ];
     for (const { rel, replace } of replacements) {

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '6.0.3';
+export const PACKAGE_VERSION = '6.1.2';
 //# sourceMappingURL=version.js.map