sneakoscope 7.3.0 → 7.5.0

package/dist/core/install/installed-package-smoke.js

@@ -30,8 +30,31 @@ export async function runInstalledPackageSmoke(root, options = {}) {
     const npmCache = path.join(tmp, 'npm-cache');
     const installPrefix = path.join(tmp, 'prefix');
     const packDestination = path.join(tmp, 'pack');
-    await Promise.all([home, codexHome, npmCache, installPrefix, packDestination, path.join(home, '.tmp')]
+    const globalRoot = path.join(tmp, 'global-sks');
+    const installCwd = path.join(tmp, 'install-cwd');
+    const runtimeTmp = path.join(tmp, 'runtime-tmp');
+    const stubBin = path.join(tmp, 'bin');
+    const launchctlLog = path.join(tmp, 'launchctl-calls.log');
+    const launchctlStub = path.join(stubBin, process.platform === 'win32' ? 'launchctl.cmd' : 'launchctl');
+    const npmUserConfig = path.join(tmp, 'npmrc');
+    const npmGlobalConfig = path.join(tmp, 'npm-globalrc');
+    await Promise.all([home, codexHome, npmCache, installPrefix, packDestination, globalRoot, installCwd, runtimeTmp, stubBin, path.join(home, '.tmp')]
         .map((dir) => fs.mkdir(dir, { recursive: true })));
+    await Promise.all([
+        fs.writeFile(launchctlLog, ''),
+        fs.writeFile(launchctlStub, launchctlStubSource()),
+        fs.writeFile(npmUserConfig, ''),
+        fs.writeFile(npmGlobalConfig, '')
+    ]);
+    await fs.chmod(launchctlStub, 0o700).catch(() => { });
+    const externalRoots = [
+        { label: 'home', root: home },
+        { label: 'codex-home', root: codexHome },
+        { label: 'global-sks', root: globalRoot },
+        { label: 'install-cwd', root: installCwd },
+        { label: 'runtime-tmp', root: runtimeTmp }
+    ];
+    const externalBeforeInstall = await snapshotTrees(externalRoots);
     const blockers = [];
     const commands = [];
     let tarball = null;
@@ -40,6 +63,14 @@ export async function runInstalledPackageSmoke(root, options = {}) {
     let packedVersion = null;
     let expectedSha256 = normalizeSha256(options.expectedSha256);
     let receiptPath = null;
+    let postinstallDefault = {
+        scripts_enabled: true,
+        external_snapshot_match: false,
+        external_findings: [],
+        launchctl_calls: [],
+        package_local_stamp_present: false,
+        opt_in_guidance_present: false
+    };
     if (options.expectedSha256 && !expectedSha256)
         blockers.push('expected_sha256_invalid');
     if (options.receipt && !options.tarball)
@@ -85,12 +116,66 @@ export async function runInstalledPackageSmoke(root, options = {}) {
         }
     }
     if (tarball && blockers.length === 0) {
-        const install = await runJsonCommand(tmp, [
-            'npm', 'install', '--global', '--prefix', installPrefix, '--ignore-scripts', '--no-audit', '--no-fund', tarball
-        ], { home, codexHome, npmCache });
+        const install = await runJsonCommand(installCwd, [
+            'npm', 'install', '--global', '--prefix', installPrefix, '--foreground-scripts', '--no-audit', '--no-fund', tarball
+        ], {
+            home,
+            codexHome,
+            npmCache,
+            env: {
+                HOME: home,
+                USERPROFILE: home,
+                CODEX_HOME: codexHome,
+                XDG_CONFIG_HOME: path.join(home, '.config'),
+                XDG_CACHE_HOME: path.join(home, '.cache'),
+                XDG_DATA_HOME: path.join(home, '.local', 'share'),
+                INIT_CWD: installCwd,
+                TMPDIR: runtimeTmp,
+                PATH: `${stubBin}${path.delimiter}${String(process.env.PATH || '')}`,
+                NODE_DISABLE_COMPILE_CACHE: '1',
+                NODE_COMPILE_CACHE: '',
+                SKS_GLOBAL_ROOT: globalRoot,
+                SKS_MENUBAR_LAUNCHCTL: launchctlStub,
+                SKS_INSTALLED_SMOKE_LAUNCHCTL_LOG: launchctlLog,
+                SKS_POSTINSTALL_BOOTSTRAP: '',
+                SKS_POSTINSTALL_NO_BOOTSTRAP: '',
+                SKS_POSTINSTALL_PROMPT: '',
+                npm_config_userconfig: npmUserConfig,
+                NPM_CONFIG_USERCONFIG: npmUserConfig,
+                npm_config_globalconfig: npmGlobalConfig,
+                NPM_CONFIG_GLOBALCONFIG: npmGlobalConfig,
+                npm_config_ignore_scripts: 'false',
+                NPM_CONFIG_IGNORE_SCRIPTS: 'false',
+                NO_UPDATE_NOTIFIER: '1'
+            }
+        });
         commands.push(summarizeInstalledSmokeCommand(install.command, 'install'));
         if (install.exit_code !== 0)
             blockers.push('npm_install_tarball_failed');
+        const externalAfterInstall = await snapshotTrees(externalRoots);
+        const externalFindings = diffTreeSnapshots(externalBeforeInstall, externalAfterInstall);
+        const launchctlCalls = await nonEmptyLines(launchctlLog);
+        const packageLocalStamp = path.join(installedPackageRoot(installPrefix), 'dist', '.sks-build-stamp.json');
+        const packageLocalStampPresent = await regularFileExists(packageLocalStamp);
+        const installOutput = `${install.stdout}\n${install.command.stderr_tail}`;
+        const optInGuidancePresent = /Automatic bootstrap was not run/.test(installOutput)
+            && /SKS_POSTINSTALL_BOOTSTRAP=1/.test(installOutput);
+        postinstallDefault = {
+            scripts_enabled: true,
+            external_snapshot_match: externalFindings.length === 0,
+            external_findings: externalFindings,
+            launchctl_calls: launchctlCalls,
+            package_local_stamp_present: packageLocalStampPresent,
+            opt_in_guidance_present: optInGuidancePresent
+        };
+        if (externalFindings.length)
+            blockers.push(...externalFindings.map((finding) => `postinstall_default_external_mutation:${finding}`));
+        if (launchctlCalls.length)
+            blockers.push('postinstall_default_launchctl_called');
+        if (!packageLocalStampPresent)
+            blockers.push('postinstall_package_local_stamp_missing');
+        if (!optInGuidancePresent)
+            blockers.push('postinstall_default_opt_in_guidance_missing');
     }
     const bin = process.platform === 'win32'
         ? path.join(installPrefix, 'sks.cmd')
@@ -187,6 +272,7 @@ export async function runInstalledPackageSmoke(root, options = {}) {
             required_dollar_commands: [...INSTALLED_REQUIRED_DOLLAR_COMMANDS],
             closure
         },
+        postinstall_default: postinstallDefault,
         forbidden_findings: forbiddenFindings,
         blockers: [...new Set(blockers)]
     };
@@ -253,6 +339,7 @@ async function runJsonCommand(cwd, argv, opts) {
         env.npm_config_cache = opts.npmCache;
         env.NPM_CONFIG_CACHE = opts.npmCache;
     }
+    Object.assign(env, opts.env || {});
     const res = await runProcess(command || 'node', args, {
         cwd,
         timeoutMs: 120_000,
@@ -275,6 +362,72 @@ async function runJsonCommand(cwd, argv, opts) {
         }
     };
 }
+async function snapshotTrees(roots) {
+    const snapshot = new Map();
+    for (const entry of roots)
+        await walkSnapshot(entry.root, entry.root, entry.label, snapshot);
+    return snapshot;
+}
+async function walkSnapshot(root, current, label, snapshot) {
+    const entries = await fs.readdir(current, { withFileTypes: true }).catch(() => []);
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+        const absolute = path.join(current, entry.name);
+        const relative = path.relative(root, absolute) || '.';
+        const key = `${label}:${relative}`;
+        const stat = await fs.lstat(absolute);
+        const mode = (stat.mode & 0o777).toString(8).padStart(3, '0');
+        if (entry.isDirectory()) {
+            snapshot.set(key, `directory:${mode}`);
+            await walkSnapshot(root, absolute, label, snapshot);
+        }
+        else if (entry.isFile()) {
+            const bytes = await fs.readFile(absolute);
+            snapshot.set(key, `file:${mode}:${bytes.length}:${crypto.createHash('sha256').update(bytes).digest('hex')}`);
+        }
+        else if (entry.isSymbolicLink()) {
+            snapshot.set(key, `symlink:${mode}:${await fs.readlink(absolute)}`);
+        }
+        else {
+            snapshot.set(key, `other:${mode}:${stat.size}`);
+        }
+    }
+}
+function diffTreeSnapshots(before, after) {
+    const findings = [];
+    const keys = [...new Set([...before.keys(), ...after.keys()])].sort();
+    for (const key of keys) {
+        if (!before.has(key))
+            findings.push(`added:${key}`);
+        else if (!after.has(key))
+            findings.push(`removed:${key}`);
+        else if (before.get(key) !== after.get(key))
+            findings.push(`changed:${key}`);
+    }
+    return findings;
+}
+async function nonEmptyLines(file) {
+    const value = await fs.readFile(file, 'utf8').catch(() => '');
+    return value.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+}
+async function regularFileExists(file) {
+    const stat = await fs.lstat(file).catch(() => null);
+    return Boolean(stat?.isFile() && !stat.isSymbolicLink());
+}
+function installedPackageRoot(prefix) {
+    return process.platform === 'win32'
+        ? path.join(prefix, 'node_modules', 'sneakoscope')
+        : path.join(prefix, 'lib', 'node_modules', 'sneakoscope');
+}
+function launchctlStubSource() {
+    if (process.platform === 'win32') {
+        return '@echo %*>>\"%SKS_INSTALLED_SMOKE_LAUNCHCTL_LOG%\"\r\n@exit /b 0\r\n';
+    }
+    return `#!/bin/sh
+printf '%s\n' "$*" >> "$SKS_INSTALLED_SMOKE_LAUNCHCTL_LOG"
+exit 0
+`;
+}
 export function validateInstalledPublicSurface(commandManifest, dollarManifest) {
     const commands = Array.isArray(commandManifest?.commands)
         ? commandManifest.commands.map((row) => String(row?.name || '')) : [];

package/dist/core/managed-path-safety.js

@@ -1,5 +1,6 @@
 import fsp from 'node:fs/promises';
 import path from 'node:path';
+import { errorCodeOf } from './errors/message.js';
 export class ManagedPathSafetyError extends Error {
     code;
     target;
@@ -73,7 +74,7 @@ export async function ensureConfinedDirectory(boundary, directory) {
                 await fsp.mkdir(current);
             }
             catch (error) {
-                if (errorCode(error) !== 'EEXIST')
+                if (errorCodeOf(error) !== 'EEXIST')
                     throw error;
             }
             stat = await lstatOrNull(current);
@@ -111,7 +112,7 @@ export async function walkConfinedEntries(boundary, root) {
             children = await fsp.readdir(current, { withFileTypes: true, encoding: 'utf8' });
         }
         catch (error) {
-            errors.push(`${errorCode(error) || 'managed_path_readdir_failed'}:${current}`);
+            errors.push(`${errorCodeOf(error) || 'managed_path_readdir_failed'}:${current}`);
             return;
         }
         children.sort((left, right) => left.name.localeCompare(right.name));
@@ -222,7 +223,7 @@ export async function removeEmptyTreeVerified(boundary, root) {
             children = await fsp.readdir(current, { withFileTypes: true, encoding: 'utf8' });
         }
         catch (error) {
-            errors.push(`${errorCode(error) || 'managed_path_readdir_failed'}:${current}`);
+            errors.push(`${errorCodeOf(error) || 'managed_path_readdir_failed'}:${current}`);
             remainingPaths.push(current);
             return;
         }
@@ -239,7 +240,7 @@ export async function removeEmptyTreeVerified(boundary, root) {
             after = await fsp.readdir(current);
         }
         catch (error) {
-            errors.push(`${errorCode(error) || 'managed_path_readdir_failed'}:${current}`);
+            errors.push(`${errorCodeOf(error) || 'managed_path_readdir_failed'}:${current}`);
             remainingPaths.push(current);
             return;
         }
@@ -251,7 +252,7 @@ export async function removeEmptyTreeVerified(boundary, root) {
             await fsp.rmdir(current);
         }
         catch (error) {
-            errors.push(`${errorCode(error) || 'managed_path_rmdir_failed'}:${current}`);
+            errors.push(`${errorCodeOf(error) || 'managed_path_rmdir_failed'}:${current}`);
             remainingPaths.push(current);
             return;
         }
@@ -270,18 +271,15 @@ export async function lstatConfinedOrNull(boundary, target) {
 export function publicPathError(error, fallback) {
     if (error instanceof ManagedPathSafetyError)
         return `${error.code}:${error.target}`;
-    return `${errorCode(error) || 'managed_path_operation_failed'}:${fallback}`;
+    return `${errorCodeOf(error) || 'managed_path_operation_failed'}:${fallback}`;
 }
 async function lstatOrNull(target) {
     try {
         return await fsp.lstat(target);
     }
     catch (error) {
-        if (errorCode(error) === 'ENOENT')
+        if (errorCodeOf(error) === 'ENOENT')
             return null;
         throw error;
     }
 }
-function errorCode(error) {
-    return error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
-}

package/dist/core/mcp-config/backup.js

@@ -1,6 +1,7 @@
 import crypto from 'node:crypto';
 import fsp from 'node:fs/promises';
 import path from 'node:path';
+import { errorCodeOf } from '../errors/message.js';
 import { nowIso, sha256, writeTextAtomic } from '../fsx.js';
 import { MCP_BACKUP_SCHEMA } from './types.js';
 export async function createMcpBackup(ref, before, operation, server) {
@@ -86,7 +87,7 @@ async function assertSafeBackupDirectory(directory, codexHome) {
     if (relative.startsWith('..') || path.isAbsolute(relative))
         throw new Error('mcp_backup_path_escape');
     for (const candidate of [path.join(codexHome, 'backups'), directory]) {
-        const stat = await fsp.lstat(candidate).catch((error) => errorCode(error) === 'ENOENT' ? null : Promise.reject(error));
+        const stat = await fsp.lstat(candidate).catch((error) => errorCodeOf(error) === 'ENOENT' ? null : Promise.reject(error));
         if (stat?.isSymbolicLink() || (stat && !stat.isDirectory()))
             throw new Error('mcp_backup_directory_invalid');
         if (stat) {
@@ -97,6 +98,3 @@ async function assertSafeBackupDirectory(directory, codexHome) {
         }
     }
 }
-function errorCode(error) {
-    return error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
-}

package/dist/core/mcp-config/config-reader.js

@@ -1,5 +1,6 @@
 import fsp from 'node:fs/promises';
 import { parseCodexConfigToml } from '../codex/codex-config-toml.js';
+import { errorCodeOf } from '../errors/message.js';
 import { publicMcpCommand, redactMcpError, redactMcpUrl, sanitizeMcpArgs } from './redaction.js';
 import { normalizeApprovalMode } from './secret-policy.js';
 import { MCP_DEFAULT_STARTUP_TIMEOUT_SEC, MCP_DEFAULT_TOOL_TIMEOUT_SEC, MCP_SERVER_CONFIG_SCHEMA } from './types.js';
@@ -16,7 +17,7 @@ export class McpConfigReadError extends Error {
     }
 }
 export async function readMcpConfigDocument(ref) {
-    const stat = await fsp.lstat(ref.configPath).catch((error) => errorCode(error) === 'ENOENT' ? null : Promise.reject(error));
+    const stat = await fsp.lstat(ref.configPath).catch((error) => errorCodeOf(error) === 'ENOENT' ? null : Promise.reject(error));
     if (!stat)
         return { ref, exists: false, text: '', parsed: {}, rawServers: {} };
     if (stat.isSymbolicLink())
@@ -142,6 +143,3 @@ function positiveNumber(value) {
     const number = Number(value);
     return Number.isFinite(number) && number > 0 ? number : null;
 }
-function errorCode(error) {
-    return error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
-}

package/dist/core/mcp-config/scope.js

@@ -1,6 +1,7 @@
 import fsp from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
+import { errorCodeOf } from '../errors/message.js';
 export class McpScopeError extends Error {
     code;
     constructor(code) {
@@ -41,7 +42,7 @@ export function isPathInside(root, candidate) {
     return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
 }
 async function assertSafeDirectory(directory, boundary, strictNoSymlink) {
-    const stat = await fsp.lstat(directory).catch((error) => errorCode(error) === 'ENOENT' ? null : Promise.reject(error));
+    const stat = await fsp.lstat(directory).catch((error) => errorCodeOf(error) === 'ENOENT' ? null : Promise.reject(error));
     if (!stat)
         return;
     if (strictNoSymlink && stat.isSymbolicLink())
@@ -53,7 +54,7 @@ async function assertSafeDirectory(directory, boundary, strictNoSymlink) {
         throw new McpScopeError('mcp_codex_home_escape_refused');
 }
 async function assertSafeConfig(configPath, boundary) {
-    const stat = await fsp.lstat(configPath).catch((error) => errorCode(error) === 'ENOENT' ? null : Promise.reject(error));
+    const stat = await fsp.lstat(configPath).catch((error) => errorCodeOf(error) === 'ENOENT' ? null : Promise.reject(error));
     if (!stat)
         return;
     if (stat.isSymbolicLink())
@@ -64,6 +65,3 @@ async function assertSafeConfig(configPath, boundary) {
     if (!resolved || !isPathInside(boundary, resolved))
         throw new McpScopeError('mcp_config_escape_refused');
 }
-function errorCode(error) {
-    return error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
-}

package/dist/core/naruto/context-graph-advisor-scope.js

@@ -0,0 +1,242 @@
+import { incomingEdges, outgoingEdges } from '../triwiki/context-graph/graph-index.js';
+import { contextGraphPathFromId } from '../triwiki/context-graph/ids.js';
+import { isWorkspaceRelativePosixPath } from '../triwiki/context-graph/paths.js';
+import { normalizeNarutoPath } from './naruto-work-item.js';
+export const NARUTO_ADVISOR_CAPS = {
+    maxDepth: 2,
+    maxNodesPerWalk: 512,
+    maxEdgesPerWalk: 4096,
+    maxSharedPathsPerPair: 12,
+    maxRecommendationsPerSlice: 24,
+    maxTaskTokens: 32,
+    maxNodesPerLabel: 8
+};
+const DEPENDENCY_EDGE_TYPES = new Set(['imports', 'reexports', 'depends_on', 'references', 'calls', 'routes_to']);
+const IMPACT_EDGE_TYPES = new Set([
+    'imports', 'reexports', 'references', 'calls', 'tests', 'affected_by', 'verified_by', 'gated_by', 'depends_on', 'owns', 'routes_to'
+]);
+const SEED_EXPANSION_EDGE_TYPES = new Set(['defines', 'contains']);
+function explanationStep(edge) {
+    return { edgeId: edge.id, type: edge.type, from: edge.from, to: edge.to, confidence: edge.confidence, path: edge.provenance.path };
+}
+function nodePathOf(node) {
+    return node.path ?? contextGraphPathFromId(node.id);
+}
+function isTestNode(node) {
+    return node.kind === 'test' || node.metadata.isTest === true;
+}
+function isProtectedGateNode(node) {
+    return node.risk === 'protected' || node.metadata.requiredForPublish === true || node.metadata.alwaysOnRelease === true;
+}
+function riskDomainOf(node) {
+    if (node.kind === 'risk_domain')
+        return node.label || null;
+    if (node.kind !== 'gate')
+        return null;
+    const declared = node.metadata.namespace;
+    return (typeof declared === 'string' && declared ? declared : node.label.split(':')[0]) || null;
+}
+export function narutoAdvisorWorkspacePath(value) {
+    const normalized = normalizeNarutoPath(value);
+    return normalized && isWorkspaceRelativePosixPath(normalized) ? normalized : null;
+}
+export function narutoAdvisorPathList(values) {
+    return [...new Set((values ?? []).map(narutoAdvisorWorkspacePath).filter((value) => value !== null))].sort();
+}
+function rootHit(nodeId) {
+    return { nodeId, depth: 0, reasonPath: [nodeId], explanation: [] };
+}
+function walkGraph(index, roots, direction, types, maxDepth) {
+    const hits = new Map();
+    const queue = [];
+    for (const root of roots) {
+        if (hits.has(root.nodeId) || !index.nodesById.has(root.nodeId))
+            continue;
+        hits.set(root.nodeId, root);
+        queue.push(root);
+    }
+    let edgesVisited = 0;
+    for (let head = 0; head < queue.length; head += 1) {
+        const current = queue[head];
+        if (!current || current.depth >= maxDepth)
+            continue;
+        for (const edge of direction === 'out' ? outgoingEdges(index, current.nodeId) : incomingEdges(index, current.nodeId)) {
+            edgesVisited += 1;
+            if (edgesVisited > NARUTO_ADVISOR_CAPS.maxEdgesPerWalk)
+                return { hits, truncated: true };
+            if (!types.has(edge.type))
+                continue;
+            const next = direction === 'out' ? edge.to : edge.from;
+            if (hits.has(next) || !index.nodesById.has(next))
+                continue;
+            if (hits.size >= NARUTO_ADVISOR_CAPS.maxNodesPerWalk)
+                return { hits, truncated: true };
+            const hit = {
+                nodeId: next,
+                depth: current.depth + 1,
+                reasonPath: [...current.reasonPath, direction === 'out' ? edge.type : `<-${edge.type}`, next],
+                explanation: [...current.explanation, explanationStep(edge)]
+            };
+            hits.set(next, hit);
+            queue.push(hit);
+        }
+    }
+    return { hits, truncated: false };
+}
+export function narutoAdvisorProvenance(index, hit) {
+    const out = [];
+    const seen = new Set();
+    for (const step of hit.explanation) {
+        const edge = index.edgesById.get(step.edgeId);
+        if (!edge)
+            continue;
+        const key = `${edge.provenance.path}#${edge.provenance.line ?? 0}#${edge.provenance.hash}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const line = edge.provenance.line;
+        out.push({ path: edge.provenance.path, ...(line === undefined ? {} : { line }), hash: edge.provenance.hash });
+    }
+    if (out.length)
+        return out;
+    const node = index.nodesById.get(hit.nodeId);
+    const nodePath = node ? nodePathOf(node) : null;
+    if (node?.contentHash && nodePath)
+        out.push({ path: nodePath, hash: node.contentHash });
+    return out;
+}
+function resolveSeedNodes(index, paths, labels, unresolved) {
+    const out = [];
+    const seen = new Set();
+    const push = (id) => {
+        if (!seen.has(id) && index.nodesById.has(id)) {
+            seen.add(id);
+            out.push(id);
+        }
+    };
+    const miss = (value) => {
+        if (value && !unresolved.includes(value))
+            unresolved.push(value);
+    };
+    for (const raw of paths) {
+        const rel = narutoAdvisorWorkspacePath(raw);
+        const ids = rel ? index.nodesByPath.get(rel) ?? [] : [];
+        if (!ids.length)
+            miss(raw);
+        for (const id of ids)
+            push(id);
+    }
+    for (const label of labels) {
+        const ids = index.nodesByLabel.get(String(label ?? '').toLowerCase()) ?? [];
+        if (!ids.length || ids.length > NARUTO_ADVISOR_CAPS.maxNodesPerLabel)
+            miss(String(label ?? ''));
+        else
+            for (const id of ids)
+                push(id);
+    }
+    return out;
+}
+export function narutoAdvisorTaskTokens(text) {
+    const tokens = [];
+    for (const raw of String(text ?? '').split(/[^\w$./-]+/)) {
+        const token = raw.replace(/^[./-]+/, '').replace(/[./-]+$/, '');
+        if (token.length < 3 || tokens.includes(token))
+            continue;
+        if (!/^[A-Za-z_$][\w$]*$/.test(token) && !/^[\w$./-]+\.[A-Za-z]\w*$/.test(token))
+            continue;
+        tokens.push(token);
+        if (tokens.length >= NARUTO_ADVISOR_CAPS.maxTaskTokens)
+            break;
+    }
+    return tokens;
+}
+function expandRoots(index, seeds) {
+    const roots = seeds.map(rootHit);
+    const seen = new Set(seeds);
+    for (const seed of seeds) {
+        for (const edge of outgoingEdges(index, seed)) {
+            if (!SEED_EXPANSION_EDGE_TYPES.has(edge.type) || seen.has(edge.to))
+                continue;
+            seen.add(edge.to);
+            roots.push({ nodeId: edge.to, depth: 0, reasonPath: [seed, edge.type, edge.to], explanation: [explanationStep(edge)] });
+            if (roots.length >= NARUTO_ADVISOR_CAPS.maxNodesPerWalk)
+                return roots;
+        }
+    }
+    return roots;
+}
+function closurePaths(index, walk) {
+    const out = new Map();
+    for (const hit of walk.hits.values()) {
+        const node = index.nodesById.get(hit.nodeId);
+        if (!node || isTestNode(node))
+            continue;
+        const nodePath = nodePathOf(node);
+        if (nodePath && !out.has(nodePath))
+            out.set(nodePath, hit);
+    }
+    return out;
+}
+function recommendationsFrom(index, sliceId, writeSet, impact) {
+    const out = [];
+    for (const hit of impact.hits.values()) {
+        const node = index.nodesById.get(hit.nodeId);
+        if (!node)
+            continue;
+        const isGate = node.kind === 'gate';
+        if (!isGate && !isTestNode(node))
+            continue;
+        const nodePath = nodePathOf(node);
+        if (!nodePath || (!isGate && writeSet.has(nodePath)))
+            continue;
+        out.push({
+            slice_id: sliceId,
+            kind: isGate ? 'gate' : 'test',
+            id: isGate ? node.label : nodePath,
+            path: nodePath,
+            protected: isGate ? isProtectedGateNode(node) : false,
+            risk_domain: isGate ? riskDomainOf(node) : null,
+            reason_path: [...hit.reasonPath],
+            explanation: [...hit.explanation],
+            provenance: narutoAdvisorProvenance(index, hit)
+        });
+        if (out.length >= NARUTO_ADVISOR_CAPS.maxRecommendationsPerSlice)
+            break;
+    }
+    return out.sort((a, b) => (a.kind === b.kind ? (a.id < b.id ? -1 : a.id > b.id ? 1 : 0) : a.kind < b.kind ? -1 : 1));
+}
+export function buildNarutoSliceState(index, slice, taskTokens, maxDepth) {
+    const unresolved = [];
+    const writePaths = narutoAdvisorPathList(slice.writePaths);
+    const labels = [...(slice.symbols ?? [])];
+    if (!writePaths.length && !labels.length)
+        labels.push(...narutoAdvisorTaskTokens(slice.title ?? ''), ...taskTokens);
+    const seeds = resolveSeedNodes(index, writePaths, labels, unresolved);
+    const walk = walkGraph(index, seeds.map(rootHit), 'out', DEPENDENCY_EDGE_TYPES, maxDepth);
+    const impact = walkGraph(index, expandRoots(index, seeds), 'in', IMPACT_EDGE_TYPES, maxDepth);
+    const closure = closurePaths(index, walk);
+    const writeSet = new Set(writePaths);
+    return {
+        scope: {
+            slice_id: slice.id,
+            seed_node_ids: [...seeds].sort(),
+            write_paths: writePaths,
+            write_closure: [...closure.keys()].sort(),
+            unresolved_seeds: [...new Set(unresolved)].sort(),
+            truncated: walk.truncated || impact.truncated
+        },
+        closure,
+        writeSet,
+        recommendations: recommendationsFrom(index, slice.id, writeSet, impact)
+    };
+}
+export function emptyNarutoScope(sliceId, slice) {
+    return {
+        slice_id: sliceId,
+        seed_node_ids: [],
+        write_paths: narutoAdvisorPathList(slice?.writePaths),
+        write_closure: [],
+        unresolved_seeds: [],
+        truncated: false
+    };
+}

package/dist/core/pipeline-internals/runtime-core.js

@@ -956,6 +956,16 @@ export async function activeRouteContext(root, state) {
         return `Route contract sealed for ${state.route_command || state.route || state.mode}. Use decision-contract.json and ${PIPELINE_PLAN_ARTIFACT} before executing the route. Before the next route phase, read relevant TriWiki context, hydrate low-trust claims from source, and refresh/validate TriWiki again after new findings or artifact changes. Next atomic action: continue the original route lifecycle with the inferred goal, constraints, non-goals, risk boundary, and test scope.${planNote}`;
     }
     if (state.mode === 'NARUTO') {
+        if (state.session_scope) {
+            const parentEvidenceState = await appNarutoParentEvidenceState(root, state);
+            if (parentEvidenceState === 'completed') {
+                return `Active Codex App Naruto mission ${state.mission_id || 'latest'} has trustworthy current-run parent evidence and a passed Naruto gate. Do not resubmit or expose the sks.subagent-parent-summary.v1 JSON. Return concise Markdown in the user's language with an explicit completion summary, verification, remaining gaps, and Honest Mode.${reasoningNote}${planNote}`;
+            }
+            if (parentEvidenceState === 'blocked') {
+                return `Active Codex App Naruto mission ${state.mission_id || 'latest'} has trustworthy current-run blocked or failed parent evidence. Do not resubmit or expose the sks.subagent-parent-summary.v1 JSON. Return concise Markdown in the user's language that states the blocker or failure first, avoids completion or success wording, and includes verification, remaining gaps, and Honest Mode.${reasoningNote}${planNote}`;
+            }
+            return `Active Codex App Naruto mission ${state.mission_id || 'latest'} uses the official Codex subagent workflow. Read subagent-plan.json, keep ${SUBAGENT_EVENT_LOG_FILENAME} and ${SUBAGENT_EVIDENCE_FILENAME} current from SubagentStart/SubagentStop, and wait for all requested agent threads. Build the exact sks.subagent-parent-summary.v1 object with run_id matching subagent-plan.json.workflow_run_id, then send it only through stdin to "sks naruto parent-summary --mission ${state.mission_id} --stdin --json". Do not expose, paste, embed, quote, or fence that JSON in the user-visible response. Only after the command accepts it, return concise Markdown in the user's language with completion summary, verification, remaining gaps/blockers, and Honest Mode. A successful response must visibly include the completion summary and Honest Mode assessment. If any parent/thread status is blocked or failed, or blockers remain, state that first and do not use completion or success wording. Do not substitute process counts, PID evidence, retired process-pool artifacts, or a custom active pool.${reasoningNote}${planNote}`;
+        }
         return `Active Naruto mission ${state.mission_id || 'latest'} uses the official Codex subagent workflow. Read subagent-plan.json, keep ${SUBAGENT_EVENT_LOG_FILENAME} and ${SUBAGENT_EVIDENCE_FILENAME} current from SubagentStart/SubagentStop, wait for all requested agent threads, then return the exact sks.subagent-parent-summary.v1 JSON result so SKS can persist ${SUBAGENT_PARENT_SUMMARY_FILENAME} and derive naruto-summary.json/naruto-gate.json. Do not substitute process counts, PID evidence, retired process-pool artifacts, or a custom active pool.${reasoningNote}${planNote}`;
     }
     if (state.subagents_required && !(await hasSubagentEvidence(root, state))) {
@@ -968,6 +978,40 @@ export async function activeRouteContext(root, state) {
     }
     return planNote.trim();
 }
+async function appNarutoParentEvidenceState(root, state) {
+    const missionId = String(state?.mission_id || '').trim();
+    const workflowRunId = String(state?.official_subagent_run_id || '').trim();
+    if (!missionId || !workflowRunId)
+        return null;
+    const dir = missionDir(root, missionId);
+    const [evidence, summary, gate] = await Promise.all([
+        subagentEvidence(root, state).catch(() => null),
+        readJson(path.join(dir, NARUTO_SUMMARY_FILENAME), null).catch(() => null),
+        readJson(path.join(dir, NARUTO_GATE_FILENAME), null).catch(() => null)
+    ]);
+    const currentRun = evidence?.run_id === workflowRunId
+        && summary?.workflow_run_id === workflowRunId
+        && gate?.workflow_run_id === workflowRunId;
+    if (!currentRun || evidence?.parent_summary_trustworthy !== true)
+        return null;
+    if (evidence.ok === true
+        && evidence.status === 'completed'
+        && summary?.status === 'completed'
+        && summary?.completion_evidence === true
+        && gate?.passed === true
+        && gate?.terminal === true
+        && gate?.terminal_state === 'completed') {
+        return 'completed';
+    }
+    if (evidence.parent_summary_status === 'failed'
+        && ['blocked', 'incomplete'].includes(String(summary?.status || ''))
+        && summary?.completion_evidence !== true
+        && gate?.passed !== true
+        && gate?.terminal_state === 'blocked') {
+        return 'blocked';
+    }
+    return null;
+}
 async function activePipelinePlanNote(root, state = {}) {
     if (!state?.mission_id)
         return '';