sneakoscope 7.0.2 → 7.0.3

package/dist/core/init.js

@@ -14,7 +14,9 @@ import { CODEX_HOOK_EVENT_STATE_KEYS } from './codex-compat/codex-hook-events.js
 import { codexCommandHookCurrentHash } from './codex-hooks/codex-hook-hash.js';
 import { buildSksCoreSkillManifest, isCoreSkillName, legacyCoreSkillNames } from './codex-native/core-skill-manifest.js';
 import { syncCoreSkillsIntegrity } from './codex-native/core-skill-integrity.js';
-import { currentGeneratedFileInventory, installCodexAgents, installGlobalSkills, installProjectSkills, installSkills, pruneStaleGeneratedFiles, REMOVED_SKS_SKILL_NAMES } from './init/skills.js';
+import { AUTHORITATIVE_SKS_SKILL_ROOT_REFERENCE } from './codex-native/sks-skill-paths.js';
+import { currentGeneratedFileInventory, installCodexAgents, pruneStaleGeneratedFiles, REMOVED_SKS_SKILL_NAMES } from './init/skills.js';
+import { reconcileManagedSkillInstallation } from './init/managed-skill-install.js';
 import { backupInvalidToml, inspectOfficialSubagentToml, mergeOfficialSubagentConfig, officialSubagentConfigOwnershipProof, officialSubagentConfigWarnings, readInheritedOfficialSubagentConfigText, resolveInheritedOfficialSubagentConfigPath } from './subagents/official-subagent-config.js';
 export { installGlobalSkills, installProjectSkills, installSkills } from './init/skills.js';
 const REFLECTION_MEMORY_PATH = '.sneakoscope/memory/q2_facts/post-route-reflection.md';
@@ -284,7 +286,7 @@ const AGENTS_BLOCK = [
     '',
     '## Codex App',
     '',
-    'Use `.codex/SNEAKOSCOPE.md`, generated `.agents/skills`, `.codex/hooks.json`, and SKS dollar commands as the app control surface.',
+    `Use \`.codex/SNEAKOSCOPE.md\`, global \`${AUTHORITATIVE_SKS_SKILL_ROOT_REFERENCE}/sks-*\`, \`.codex/hooks.json\`, and SKS dollar commands as the app control surface. Managed SKS skill files are re-resolved by UserPromptSubmit, compact-resume SessionStart, active PreToolUse, and SubagentStart; current files override stale project-local, \`.codex/skills\`, plugin-cache, picker, pre-compaction, and prior-message paths. After a successful remap, read the current file silently without reporting a path mismatch.`,
     ''
 ].join('\n');
 export function agentsBlockText() {
@@ -310,7 +312,7 @@ export async function initProject(root, opts = {}) {
             created.push(`repaired generated SKS files (${repair.removed.length})`);
     }
     const dirs = [
-        '.sneakoscope/state', '.sneakoscope/missions', '.sneakoscope/db', '.sneakoscope/bus', '.sneakoscope/hproof', '.sneakoscope/db', '.sneakoscope/wiki', '.sneakoscope/skills', '.sneakoscope/memory/q0_raw', '.sneakoscope/memory/q1_evidence', '.sneakoscope/memory/q2_facts', '.sneakoscope/memory/q3_tags', '.sneakoscope/memory/q4_bits', '.sneakoscope/gx/cartridges', '.sneakoscope/model/fingerprints', '.sneakoscope/genome/candidates', '.sneakoscope/trajectories/raw', '.sneakoscope/locks', '.sneakoscope/tmp', '.sneakoscope/arenas', '.sneakoscope/reports', '.codex', '.codex/agents', '.agents/skills'
+        '.sneakoscope/state', '.sneakoscope/missions', '.sneakoscope/db', '.sneakoscope/bus', '.sneakoscope/hproof', '.sneakoscope/db', '.sneakoscope/wiki', '.sneakoscope/skills', '.sneakoscope/memory/q0_raw', '.sneakoscope/memory/q1_evidence', '.sneakoscope/memory/q2_facts', '.sneakoscope/memory/q3_tags', '.sneakoscope/memory/q4_bits', '.sneakoscope/gx/cartridges', '.sneakoscope/model/fingerprints', '.sneakoscope/genome/candidates', '.sneakoscope/trajectories/raw', '.sneakoscope/locks', '.sneakoscope/tmp', '.sneakoscope/arenas', '.sneakoscope/reports', '.codex', '.codex/agents'
     ];
     for (const d of dirs)
         await ensureDir(path.join(root, d));
@@ -339,7 +341,8 @@ export async function initProject(root, opts = {}) {
         codex_app: {
             config: '.codex/config.toml',
             hooks: '.codex/hooks.json',
-            skills: '.agents/skills',
+            skills: AUTHORITATIVE_SKS_SKILL_ROOT_REFERENCE,
+            project_skills_policy: '.agents/skills is not the authoritative managed SKS install root',
             legacy_skills_dir_removed: '.codex/skills',
             agents: '.codex/agents',
             quick_reference: '.codex/SNEAKOSCOPE.md',
@@ -574,7 +577,8 @@ export async function initProject(root, opts = {}) {
                 supported: true,
                 config: '.codex/config.toml',
                 hooks: '.codex/hooks.json',
-                skills: '.agents/skills',
+                skills: AUTHORITATIVE_SKS_SKILL_ROOT_REFERENCE,
+                project_skills_policy: '.agents/skills is not the authoritative managed SKS install root',
                 legacy_skills_dir_removed: '.codex/skills',
                 agents: '.codex/agents',
                 quick_reference: '.codex/SNEAKOSCOPE.md',
@@ -625,15 +629,6 @@ export async function initProject(root, opts = {}) {
             project_install: 'npm i -D sneakoscope && npx sks setup --install-scope project'
         };
     }
-    // SKS-managed Codex App feature flags. Seeded as defaults for fresh configs but
-    // NEVER force-re-enabled on upgrade: force-writing these reverted a user's
-    // `enabled = false` and blanked/broke the Codex App UI (same rationale as the
-    // install-helpers path). All are SET-IF-ABSENT below.
-    // Only flags present in the current official [features] reference. Flags SKS
-    // wrote before the 2026-07 renewal that no longer exist (remote_control,
-    // fast_mode_ui, codex_git_commit, computer_use, browser_use, browser_use_external,
-    // image_generation, in_app_browser, guardian_approval, tool_suggest, plugins) are
-    // stripped below instead.
     const MANAGED_CODEX_FEATURE_FLAGS = ['hooks', 'multi_agent', 'fast_mode', 'apps'];
     const REMOVED_CODEX_FEATURE_FLAGS = [
         'remote_control', 'fast_mode_ui', 'codex_git_commit', 'computer_use', 'browser_use',
@@ -645,8 +640,6 @@ export async function initProject(root, opts = {}) {
         next = removeTomlTableKey(next, 'notice', 'fast_default_opt_out');
         next = removeTomlTableKey(next, 'features', 'codex_hooks');
         next = upsertTopLevelTomlBooleanIfAbsent(next, 'suppress_unstable_features_warning', true);
-        // Codex App feature flags: SET-IF-ABSENT only (see note above); flags the
-        // 2026-07 renewal removed from the schema are stripped.
         for (const flag of MANAGED_CODEX_FEATURE_FLAGS) {
             next = upsertTomlTableKeyIfAbsent(next, 'features', `${flag} = true`);
         }
@@ -665,8 +658,6 @@ export async function initProject(root, opts = {}) {
                 continue;
             next = upsertTomlTable(next, block.table, block.text);
         }
-        // Plugin tables broke the Codex App UI by force-reverting user `enabled=false`.
-        // Auto-enable is opt-in only, and even then never overwrites an existing table.
         if (process.env.SKS_MANAGE_CODEX_APP_PLUGINS === '1') {
             for (const [name, marketplace] of DEFAULT_CODEX_APP_PLUGINS) {
                 const table = `plugins."${name}@${marketplace}"`;
@@ -864,9 +855,7 @@ export async function initProject(root, opts = {}) {
     }
     function managedCodexConfigBlocks() {
         return [
-            // Preserve existing Context7 credentials; seed remote transport to avoid invalid merged command/url stdio config.
             { table: 'mcp_servers.context7', text: context7ConfigToml('remote').trim(), preserveExisting: true },
-            // Profiles use per-file CODEX_HOME overlays owned by auto-review migration; do not emit deprecated profile tables.
             {
                 table: 'auto_review',
                 text: '[auto_review]\npolicy = "In MAD-SKS launches, allow only the scoped high-risk surfaces approved for the active invocation. The explicit sks mad-sks sql|apply-migration invocation is the SQL-plane approval boundary: execute only requested SQL-plane mutations with mission-local write transport, literal catastrophic-intent binding, read-back proof, and final read-only restoration. Supabase project/account/billing/credential control-plane actions remain denied."'
@@ -948,8 +937,6 @@ export async function initProject(root, opts = {}) {
     let codexConfigInstall;
     if (!existingConfigValidation.ok) {
         const backupPath = await backupInvalidToml(generatedCodexConfigPath, existingCodexConfig, 'project-config-invalid');
-        // repairSksGeneratedArtifacts may have removed the path before this stage;
-        // invalid user TOML is still restored byte-for-byte and never normalized.
         await writeTextAtomic(generatedCodexConfigPath, existingCodexConfig);
         codexConfigInstall = {
             ok: false,
@@ -968,11 +955,6 @@ export async function initProject(root, opts = {}) {
         });
         const inheritedConfigValidation = inspectOfficialSubagentToml(inheritedCodexConfig);
         if (!inheritedConfigValidation.ok) {
-            // A malformed inherited CODEX_HOME config is an operator-owned blocker,
-            // not an empty layer. Do not derive or write a project config from it.
-            // Repair mode may have removed an SKS-generated project config earlier,
-            // so restore that project text byte-for-byte while leaving the inherited
-            // file untouched.
             if (String(existingCodexConfig || '').length > 0) {
                 await writeTextAtomic(generatedCodexConfigPath, existingCodexConfig);
             }
@@ -1037,17 +1019,8 @@ export async function initProject(root, opts = {}) {
         await writeTextAtomic(generatedCodexConfigPath, mergeManagedHookTrustStateToml(await readText(generatedCodexConfigPath, ''), root, hookCommandPrefix));
         created.push('.codex/config.toml hook trust state');
     }
-    const skillInstall = installScope === 'project' ? await installProjectSkills(root) : await installGlobalSkills(root);
-    created.push(installScope === 'project' ? '.agents/skills official residue reconciled' : '.agents/skills/*');
-    const removedStaleGeneratedSkills = skillInstall.removed_stale_generated_skills || skillInstall.removed || [];
-    const removedAgentSkillAliases = skillInstall.removed_agent_skill_aliases || [];
-    const removedCodexSkillMirrors = skillInstall.removed_codex_skill_mirrors || [];
-    if (removedStaleGeneratedSkills.length)
-        created.push(`stale generated skills removed (${removedStaleGeneratedSkills.length})`);
-    if (removedAgentSkillAliases.length)
-        created.push(`deprecated generated skill aliases removed (${removedAgentSkillAliases.length})`);
-    if (removedCodexSkillMirrors.length)
-        created.push(`.codex/skills generated mirrors removed (${removedCodexSkillMirrors.length})`);
+    const { skillInstall, created: skillInstallCreated } = await reconcileManagedSkillInstallation(root, opts.home);
+    created.push(...skillInstallCreated);
     const agentInstall = await installCodexAgents(root);
     created.push(`.codex/agents official subagent catalog (${agentInstall.installed_agents?.length || 0})`);
     if (agentInstall.retired_role_cleanup?.removed_count)
@@ -1058,7 +1031,8 @@ export async function initProject(root, opts = {}) {
         created.push(`official subagent agent config manual blockers (${agentInstall.manual_blockers.length})`);
     const configInventoryOwned = codexConfigInstall.ok && (configWasFresh || configPreviouslySksOwned);
     const generatedFiles = currentGeneratedFileInventory(skillInstall, agentInstall, {
-        includeCodexConfig: configInventoryOwned
+        includeCodexConfig: configInventoryOwned,
+        includeSkillFiles: false
     });
     const generatedCleanup = await pruneStaleGeneratedFiles(root, previousManifest, generatedFiles);
     if (generatedCleanup.pruned.length)
@@ -1164,7 +1138,8 @@ export function codexAppQuickReference(scope, commandPrefix) {
         '# ㅅㅋㅅ',
         `Install scope: \`${scope}\``,
         `Command: \`${commandPrefix} <command>\``,
-        'Files: AGENTS.md, .codex/hooks.json, .codex/config.toml, .codex/SNEAKOSCOPE.md, .agents/skills, .codex/agents, .sneakoscope/missions.',
+        `Files: AGENTS.md, .codex/hooks.json, .codex/config.toml, .codex/SNEAKOSCOPE.md, ${AUTHORITATIVE_SKS_SKILL_ROOT_REFERENCE}/sks-* (authoritative managed SKS skills), .codex/agents, .sneakoscope/missions.`,
+        `Skill paths: UserPromptSubmit, compact-resume SessionStart, active PreToolUse, and SubagentStart re-resolve files under ${AUTHORITATIVE_SKS_SKILL_ROOT_REFERENCE}/sks-*/SKILL.md. Current files override stale project-local, .codex/skills, plugin-cache, picker, pre-compaction, and prior-message links. Successful remaps stay silent; unresolved skills are never guessed.`,
         `Discover: ${commandPrefix} bootstrap; ${commandPrefix} deps check; ${commandPrefix} commands; ${commandPrefix} codex-app check; ${commandPrefix} codex-app remote-control --status; npm run zellij:capability; ${commandPrefix} dollar-commands; ${commandPrefix} pipeline status; ${commandPrefix} pipeline plan.`,
         coreEngineeringDirectiveReferenceText(),
         'dollar-commands:',

package/dist/core/lean-engineering-policy.js

@@ -22,8 +22,6 @@ export const LEAN_ENGINEERING_POLICY_HASH = createHash('sha256')
     .update(LEAN_ENGINEERING_POLICY_CANONICAL)
     .digest('hex')
     .slice(0, 16);
-// Keep the legacy policy identifiers stable for persisted evidence while the
-// user-facing directive stays concise and authoritative.
 export const CORE_ENGINEERING_DIRECTIVE_ID = 'sks.core-engineering-directive.v1';
 export const CORE_ENGINEERING_DIRECTIVE_HASH = LEAN_ENGINEERING_POLICY_HASH;
 export function leanPolicyReference() {

package/dist/core/locks/file-lock.js

@@ -73,12 +73,7 @@ async function holdFileLock(lockPath, staleMs, held, fn) {
             await writeOwnerFile(lockPath, held.owner, staleMs, held.protectedPids);
         }
     };
-    // Touch the owner file's heartbeat_at while we hold the lock so a stale
-    // waiter never mistakes genuinely slow-but-alive work for an abandoned
-    // lock (20차 P1-1) — recoverStaleLock only reclaims when both the
-    // heartbeat is old AND the owning pid is actually dead.
     const heartbeat = setInterval(() => {
-        /* intentional: a missed heartbeat tick just gets retried next interval; only matters if it stays stale for the full staleMs window */
         writeOwnerFile(lockPath, held.owner, staleMs, held.protectedPids).catch(() => undefined);
     }, Math.max(250, Math.floor(staleMs / HEARTBEAT_MARGIN)));
     if (typeof heartbeat.unref === 'function')
@@ -88,7 +83,6 @@ async function holdFileLock(lockPath, staleMs, held, fn) {
     }
     finally {
         clearInterval(heartbeat);
-        /* intentional: best-effort release — if it fails, the lock will still be reclaimed once it goes stale (owner-token/pid checked, never blind rm) */
         await releaseIfOwned(lockPath, held.owner).catch(() => undefined);
     }
 }
@@ -106,19 +100,11 @@ async function writeOwnerFile(lockPath, owner, staleMs, protectedPids) {
         ...(protectedPids.size > 0 ? { protected_pids: [...protectedPids].sort((a, b) => a - b) } : {})
     });
 }
-// Reclaims an abandoned lock without ever directly deleting a lock another
-// process might still legitimately hold. A dead-or-expired lock is renamed
-// (a single atomic syscall) into a quarantine directory first; only the one
-// waiter whose rename succeeds proceeds to retry acquisition, so two
-// concurrent waiters can never both believe they reclaimed the same lock
-// (the previous mtime-only check + direct rm -rf allowed exactly that).
 async function recoverStaleLock(lockPath, requestedStaleMs) {
     const ownerPath = path.join(lockPath, 'owner.json');
     const info = await readJson(ownerPath, null);
     let stale;
     if (!info || typeof info.pid !== 'number' || !info.heartbeat_at) {
-        // No readable owner record: fall back to directory mtime so a lock left
-        // over from before this format existed can still be reclaimed.
         stale = await isDirMtimeStale(lockPath, Math.max(1, requestedStaleMs));
     }
     else {
@@ -135,10 +121,8 @@ async function recoverStaleLock(lockPath, requestedStaleMs) {
         await fsp.rename(lockPath, quarantinePath);
     }
     catch {
-        // Another waiter already reclaimed (or the holder released) it first.
         return false;
     }
-    /* intentional: the quarantine rename already reclaimed the lock name; this is just disk cleanup of the orphaned directory and can be swept up later if it fails */
     await guardedRm(guardContextForRoute(process.cwd(), lockScopeContract(quarantinePath), 'remove quarantined stale SKS file lock directory'), quarantinePath, {
         recursive: true,
         force: true
@@ -147,9 +131,6 @@ async function recoverStaleLock(lockPath, requestedStaleMs) {
 }
 async function releaseIfOwned(lockPath, owner) {
     const info = await readJson(path.join(lockPath, 'owner.json'), null);
-    // If the owner record is missing or names a different owner, this lock was
-    // already reclaimed as stale out from under us — removing it now would
-    // delete whoever holds it legitimately next.
     if (info && info.owner !== owner)
         return;
     await removeLockDir(lockPath);
@@ -167,8 +148,6 @@ async function removeLockDir(lockPath) {
     });
 }
 function isPidAlive(pid, hostname) {
-    // A pid recorded on a different host can't be liveness-checked locally;
-    // treat it as alive (never force-reclaim across hosts from mtime alone).
     if (hostname && hostname !== os.hostname())
         return true;
     try {

package/dist/core/loops/loop-planner.js

@@ -162,10 +162,6 @@ function makeNode(input) {
         risk: input.risk
     };
 }
-// Maker parallelism scales with the loop's owned scope instead of a flat 2:
-// Naruto can fan out far wider, and a fixed count starved wide scopes while
-// over-provisioning single-file loops. Risk still clamps the ceiling so
-// critical work cannot stampede, and 'safe' mode keeps the old behavior.
 function dynamicMakerWorkerCount(input) {
     if (input.route === '$Integration')
         return 1;
@@ -176,8 +172,6 @@ function dynamicMakerWorkerCount(input) {
     const scopeScaled = Math.max(riskFloor, Math.ceil(scopeSize / 3));
     return Math.max(1, Math.min(modeCap, riskCap, scopeScaled));
 }
-// Checker workers are read-only GPT review lanes. They scale more conservatively
-// than makers, but wide/high-risk owner scopes get more than one fresh reviewer.
 function dynamicCheckerWorkerCount(input) {
     if (input.route === '$Integration')
         return 1;

package/dist/core/loops/loop-runtime.js

@@ -95,7 +95,6 @@ export async function runLoopNode(input) {
             plan: input.plan,
             node,
             worktree: { id: worktree.worktree_id || lease.worktree_id, path: worktree.path, branch: worktree.branch },
-            // Checker is read-only by definition; fixture mode requires an explicit test-only runtime flag.
             noMutation: true,
             makerArtifacts: maker.artifacts
         });

package/dist/core/loops/loop-worker-runtime.js

@@ -19,10 +19,6 @@ async function runLoopWorkers(input) {
         return runLoopWorkerFixture(input);
     return runLoopWorkerNative(input);
 }
-// `noMutation` used to force fixture mode here, which silently turned EVERY
-// checker run into a deterministic fixture (checkers always pass
-// noMutation: true for read-only semantics) — real model verification never
-// happened. Fixture mode is now an explicit, separate test-only signal.
 function shouldUseFixture(input) {
     const requested = input.fixture === true || process.env.SKS_LOOP_RUNTIME_FIXTURE === '1';
     if (!requested)
@@ -52,13 +48,6 @@ async function runLoopWorkerNative(input) {
         desiredCapability: 'agent-role'
     }).catch(() => null);
     const workGraph = buildLoopNarutoWorkGraph(input, workerCount, executionProfile, invocationPlan);
-    // Root-cause-1 fix: keep the ORCHESTRATOR root on the MAIN repo (input.root), not the
-    // loop worktree. All zellij/right-column/slot-telemetry state derives from the orchestrator
-    // root, so anchoring it on input.root makes the SLOTS snapshot land under
-    // <main repo>/.sneakoscope/missions/<missionId>/... where the main session's anchor + slot
-    // renderer panes watch it (previously it landed under the worktree and went permanently stale).
-    // The loop worktree is still where workers cwd + write: it is threaded through the per-worker
-    // `worktree` opt below, which launchWorker reads as ctx.opts.worktree -> workerCwd.
     const insideZellij = Boolean(process.env.SKS_ZELLIJ_SESSION_NAME || process.env.ZELLIJ);
     const visiblePaneCap = Math.min(resolveLoopVisiblePaneCap(workerCount), Math.max(1, workerCount));
     const zellijPlacementOpts = insideZellij ? {
@@ -74,11 +63,6 @@ async function runLoopWorkerNative(input) {
         backend: 'codex-sdk',
         readonly: input.phase === 'checker',
         workspaceWrite: input.phase === 'maker',
-        // Bug fix: agents must be explicitly bounded to workerCount here. Without it,
-        // buildAgentRoster()'s normalizeAgentCount() falls back to DEFAULT_AGENT_COUNT (5)
-        // while maxAgentCount below is capped to workerCount, so any loop node with a
-        // worker_count/max_subagents budget under 5 (the common case) threw
-        // "Agent count 5 exceeds max N" instead of clamping to the smaller budget.
         agents: Math.max(1, workerCount),
         desiredWorkItemCount: workGraph.total_work_items,
         minimumWorkItems: 1,
@@ -321,9 +305,6 @@ function stringArray(value) {
         return [];
     return [...new Set(value.flat().map((item) => String(item || '').trim()).filter(Boolean))];
 }
-// Visible pane cap for loop workers: defaults to min(4, workers) so the right
-// column stays readable; SKS_ZELLIJ_VISIBLE_PANE_CAP overrides for tall
-// terminals (overflow workers run headless and stay visible in SLOTS rows).
 function resolveLoopVisiblePaneCap(workerCount) {
     const fromEnv = Number(process.env.SKS_ZELLIJ_VISIBLE_PANE_CAP || 0);
     if (Number.isFinite(fromEnv) && fromEnv >= 1)

package/dist/core/mad-sks/executors/db-write-executor.js

@@ -31,10 +31,6 @@ export async function runDbWrite(input, context, dryRun = Boolean(input.dry_run)
     });
     if (!guard.ok)
         blockers.push(...guard.issues);
-    // db-write-executor has no execution engine — it never calls the MAD-SKS SQL-plane cycle (or any
-    // adapter) to actually run SQL against a database. It can only produce a preview
-    // plan. A real apply must therefore always be blocked here rather than fabricate
-    // an 'applied' result; the actual execution route is the sql-plane executor.
     if (!dryRun)
         blockers.push('db_write_executor_no_execution_engine_use_sql_plane_executor');
     if (blockers.length) {

package/dist/core/mad-sks/executors/executor-base.js

@@ -42,21 +42,11 @@ export function executorBlocker({ executor, actionType, context, blockers, block
         generated_at: nowIso()
     };
 }
-// Capture the protected-core snapshot BEFORE an executor performs any
-// mutation. writeExecutorEvidence() runs after the mutation is already done
-// (it needs the resulting changedFiles/hashes), so it cannot itself take an
-// honest "before" snapshot — doing so there always compared post-mutation
-// state against post-mutation state, structurally guaranteeing
-// protected_core_unchanged: true regardless of what actually happened
-// (20차 P0-7). Call this first, then pass the result to writeExecutorEvidence.
 export async function snapshotProtectedCoreBefore(context, executor) {
     return snapshotProtectedCore(context.package_root, `${executor}-before`);
 }
 export async function writeExecutorEvidence({ context, executor, actionType, beforeSnapshot, changedFiles = [], blockedActions = [], fileRollbacks = [], packageRollbacks = [], serviceRollbacks = [], dbRollbacks = [], rollbackUnavailable = [], auditActions = [], verification = [], forceProtectedCoreChanged = false }) {
     await ensureDir(context.artifact_dir);
-    // Falls back to a call-time snapshot only when the caller didn't capture
-    // one before mutating (e.g. blocked/dry-run paths where nothing changed) —
-    // callers that perform a real mutation must pass beforeSnapshot.
     const before = beforeSnapshot || await snapshotProtectedCore(context.package_root, `${executor}-before`);
     const after = await snapshotProtectedCore(context.package_root, `${executor}-after`);
     const comparison = forceProtectedCoreChanged && (process.env.NODE_ENV === 'test' || process.env.SKS_TEST_FORCE_PROTECTED_CORE_CHANGED === '1')

package/dist/core/mad-sks/immutable-harness-guard.js

@@ -188,11 +188,6 @@ async function hashProtectedEntry(entry) {
     }
     return { id: entry.id, path: entry.path, relative_path: entry.path, present: true, hash: sha256(parts.join('\n')), file_count: files.length, bytes };
 }
-// Cheap variant of hashProtectedEntry: hash only filesystem metadata
-// (mtimeMs + size + mode) instead of reading + sha256-ing file contents. Walks the
-// same file set so file_count/bytes stay comparable, but avoids the ~10MB read +
-// per-file sha256 cost. Only used for the never-compared interactive launch 'before'
-// snapshot; integrity-critical callers keep the default 'content' mode.
 async function metadataHashProtectedEntry(entry) {
     if (!(await exists(entry.absolute_path))) {
         return { id: entry.id, path: entry.path, relative_path: entry.path, present: false, hash: null, file_count: 0, bytes: 0 };

package/dist/core/mad-sks/sql-plane/coordinator.js

@@ -218,11 +218,6 @@ export async function runMadSksSqlPlaneCycle(input) {
         }
     }
     catch (err) {
-        // Previously discarded whenever blockers was already non-empty (e.g. a
-        // prior execution failure), silently hiding any *new* exception raised
-        // during read-back verification (20차 P1-7) — always recorded now,
-        // distinctly prefixed once there's already a domain-level blocker so it
-        // isn't mistaken for one.
         const message = err instanceof Error ? err.message : String(err);
         blockers.push(blockers.length ? `mad_sks_sql_plane_cycle_exception:${message}` : message);
     }

package/dist/core/mad-sks/sql-plane/ledger.js

@@ -11,10 +11,6 @@ export async function appendMadSksSqlPlaneLedgerEvent(root, missionId, event) {
     };
     const dir = madSksSqlPlaneDir(root, missionId);
     await appendJsonlBounded(path.join(dir, MAD_SKS_SQL_PLANE_LEDGER_FILE), row);
-    // The authoritative append above already succeeded or threw; this is a
-    // convenience "latest" pointer only. Its failure used to vanish silently
-    // (20차 P1-7) — readers of the latest-event pointer could see a stale
-    // pointer with no signal anything was wrong.
     await writeJsonAtomic(path.join(dir, MAD_SKS_SQL_PLANE_LATEST_LEDGER_FILE), row).catch((err) => {
         console.error(`MAD-SKS SQL-plane ledger: failed to update latest pointer for mission ${missionId}: ${err instanceof Error ? err.message : String(err)}`);
     });

package/dist/core/mad-sks/sql-plane/lock.js

@@ -2,10 +2,6 @@ import path from 'node:path';
 import { ensureDir } from '../../fsx.js';
 import { withFileLock } from '../../locks/file-lock.js';
 import { madSksSqlPlaneRuntimeDir } from './paths.js';
-// Previously a bespoke mkdir-lock with no owner-pid check and no stale
-// recovery at all — a crash mid-operation left the lock permanently stuck
-// (20차 P1-3). Reuses the single owner-token + heartbeat + quarantine-reclaim
-// lock implementation from core/locks/file-lock.ts instead of a second one.
 export async function withMadSksSqlPlaneLock(root, missionId, name, fn) {
     const dir = path.join(madSksSqlPlaneRuntimeDir(root, missionId), 'locks');
     await ensureDir(dir);

package/dist/core/mad-sks/sql-plane/mcp-executor.js

@@ -5,14 +5,6 @@ export class MadSksSqlPlaneMcpExecutor {
     opts;
     client = null;
     transport = null;
-    // A successful inventory() result is cached for this executor instance's
-    // lifetime (one DB operation cycle) — previously every executeSql/
-    // applyMigration call re-fetched the full tool list from the MCP server
-    // via callToolWithFallback, on top of whatever explicit inventory() the
-    // caller had already done to prepare the mission, doubling the
-    // connect+listTools round trip per SQL call for no reason the available
-    // tool set can't change mid-cycle (20차 P2-5b). Failures are never
-    // cached, so a transient listTools error doesn't get stuck.
     cachedInventory = null;
     constructor(profile, opts = {}) {
         this.profile = profile;
@@ -78,7 +70,6 @@ export class MadSksSqlPlaneMcpExecutor {
         return this.callToolWithFallback(['apply_migration', 'supabase.apply_migration'], [{ name, query: sql }, { name, sql }]);
     }
     async close() {
-        /* intentional: best-effort teardown on close, session/client are being discarded either way */
         await this.transport?.terminateSession().catch(() => undefined);
         await this.client?.close().catch(() => undefined);
         this.client = null;

package/dist/core/mad-sks/sql-plane/policy-resolver.js

@@ -7,7 +7,6 @@ export async function resolveMadSksSqlPlaneMutationPolicy(root, state = {}, clas
     const primary = await resolveMadSksSqlPlaneMutationPolicyForState(root, state, classification, explicitCapability);
     if (primary.allowed === true || explicitCapability)
         return primary;
-    /* intentional: optional fallback lookup — primary policy already resolved, this only widens the search */
     const persistedState = await readJson(stateFile(root), null).catch(() => null);
     if (persistedState && persistedState !== state) {
         const fallback = await resolveMadSksSqlPlaneMutationPolicyForState(root, persistedState, classification, null);
@@ -42,7 +41,6 @@ async function findLatestActiveMadSksSqlPlaneCapability(root) {
     for (const entry of entries) {
         if (!entry.isDirectory() || !entry.name.startsWith('M-'))
             continue;
-        /* intentional: scanning candidate mission dirs for an active capability — a missing/corrupt one is just not a candidate */
         const capability = await readMadSksSqlPlaneCapability(root, entry.name).catch(() => null);
         if (!capability || !isMadSksSqlPlaneCapabilityActive(capability))
             continue;

package/dist/core/mad-sks/sql-plane/postconditions.js

@@ -6,10 +6,6 @@ export async function runReadBackChecks(input) {
     for (const check of input.checks) {
         const result = await input.executor.executeSql(check.query);
         const queryOk = result.ok === (check.expectOk ?? true);
-        // Query success alone doesn't prove the write took effect — a verify SQL
-        // can succeed while returning zero/unexpected rows. When the caller
-        // supplied an expected row_count or result_digest, the check must match
-        // it to pass (20차 P0-10); without one, this stays query-success-only.
         const rowCountMatched = check.expectedRowCount === undefined || check.expectedRowCount === null
             ? null
             : result.row_count === check.expectedRowCount;

package/dist/core/mad-sks/sql-plane/recovery.js

@@ -16,14 +16,12 @@ export async function quarantineStaleMadSksSqlPlaneRuntimeProfiles(root) {
         if (!(await exists(profile)))
             continue;
         const dest = `${profile}.quarantined-${Date.now()}`;
-        /* intentional: best-effort rename-then-rm quarantine of a leftover config; nothing depends on this file surviving */
         await fs.rename(profile, dest).catch(async () => {
             await fs.rm(profile, { force: true }).catch(() => undefined);
         });
         quarantined.push(path.relative(root, dest).split(path.sep).join('/'));
     }
     const report = { schema: 'sks.mad-sks-sql-plane-recovery.v1', ok: true, quarantined, checked_at: nowIso() };
-    /* intentional: recovery report is diagnostic-only, already returned to the caller regardless of whether it persisted */
     await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'mad-sks-sql-plane-recovery.json'), report).catch(() => undefined);
     return report;
 }

package/dist/core/mad-sks/sql-plane/runtime-profile.js

@@ -6,13 +6,6 @@ export async function createMadSksSqlPlaneRuntimeProfile(input) {
     const dir = madSksSqlPlaneRuntimeDir(input.root, input.missionId);
     await fs.mkdir(dir, { recursive: true });
     const url = madSksSqlPlaneMcpUrl(input.projectRef, input.mcpUrl);
-    /* intentional: this TOML block is never loaded into a live Codex session config — the
-       agent's own Supabase MCP tool intentionally stays read-only for the whole cycle. It is
-       read only by MadSksSqlPlaneMcpExecutor (via profile.server_url in-process) and by
-       recovery.ts (existence check for crash cleanup). Keeping writes on that single
-       JS-orchestrated path, rather than handing the model a write-capable MCP server directly,
-       is what makes postcondition/read-back/rollback verification possible; do not "wire this up"
-       into .codex/config.toml without re-deriving those guarantees for a model-driven write path. */
     const text = [
         '[mcp_servers.supabase_mad_sks_sql_plane]',
         `url = "${url}"`,
@@ -47,7 +40,6 @@ export async function closeMadSksSqlPlaneRuntimeProfile(input) {
     const profilePath = input.profile?.profile_path ? path.join(input.root, input.profile.profile_path) : path.join(runtimeDir, 'codex-mad-sks-sql-plane.config.toml');
     if (await exists(profilePath)) {
         const quarantine = `${profilePath}.closed`;
-        /* intentional: best-effort rename-then-rm quarantine of the closed runtime profile; read-only restoration is verified separately below */
         await fs.rename(profilePath, quarantine).catch(async () => {
             await fs.rm(profilePath, { force: true }).catch(() => undefined);
         });

package/dist/core/managed-assets/managed-assets-manifest.js

@@ -1,10 +1,9 @@
 import { sha256 } from '../fsx.js';
 import { subagentModelProfile } from '../subagents/model-policy.js';
 export const MANAGED_ASSET_SCHEMA_VERSION = 1;
-export const MANAGED_ASSET_VERSION = '7.0.2';
+export const MANAGED_ASSET_VERSION = '7.0.3';
 export const MANAGED_ASSET_MARKER = 'SKS-MANAGED-ASSET';
 export const MANAGED_OFFICIAL_SUBAGENT_MARKER = 'SKS-MANAGED-OFFICIAL-SUBAGENT';
-/** Internal cleanup tombstones for SKS-owned role files retired from the installed catalog. */
 export const RETIRED_MANAGED_AGENT_ROLE_TOMBSTONES = Object.freeze([
     role('sks-explorer', 'analysis-scout.toml', 'analysis_scout', 'SKS analysis scout for bounded read/write slices retained for stale Codex agent-role config repair.', 'workspace-write', ['analysis-scout', 'analysis_scout']),
     role('sks-native-agent', 'native-agent-intake.toml', 'native_agent', 'SKS native agent for bounded read/write intake slices.', 'workspace-write', ['native-agent-intake', 'native_agent']),
@@ -16,11 +15,6 @@ export const RETIRED_MANAGED_AGENT_ROLE_TOMBSTONES = Object.freeze([
     role('sks-codex-probe-verifier', 'sks-codex-probe-verifier.toml', 'sks_codex_probe_verifier', 'Codex probe verifier for CLI, App, SDK, MCP, and native capability evidence with bounded write capability.', 'workspace-write', ['codex-probe-verifier']),
     role('db-safety-reviewer', 'db-safety-reviewer.toml', 'db_safety_reviewer', 'Database safety reviewer for SQL, migrations, Supabase, and rollback safety with bounded write capability.', 'workspace-write', ['db-safety-reviewer', 'db_safety_reviewer'])
 ]);
-/**
- * Canonical project-scoped Codex custom agents for the official subagent workflow.
- * Each role is intentionally narrow so Codex can select it from its description
- * instead of forcing every slice through a generic worker/reviewer pair.
- */
 export const MANAGED_OFFICIAL_SUBAGENT_ROLES = Object.freeze([
     officialSubagentRole({
         id: 'sks-official-worker',

package/dist/core/mcp-config/health-check.js

@@ -87,7 +87,7 @@ async function probeStdio(name, scope, raw, options) {
         const list = isRecord(tools) && isRecord(tools.result) && Array.isArray(tools.result.tools) ? tools.result.tools : null;
         if (!list)
             return result(name, scope, 'protocol_error', protocol, null, instructions, null, 'mcp_tools_list_invalid', options);
-        return result(name, scope, 'healthy', protocol, list.length, instructions, null, null, options);
+        return result(name, scope, 'healthy', protocol, list.length, instructions, null, null, options, toolNames(list));
     }
     catch (error) {
         const message = redactMcpError(error);
@@ -132,7 +132,7 @@ async function probeHttp(name, scope, raw, options) {
             ? tools.json.result.tools : null;
         if (!list)
             return result(name, scope, 'protocol_error', protocol, null, instructions, null, `mcp_http_tools_${tools.status}`, options);
-        return result(name, scope, 'healthy', protocol, list.length, instructions, null, null, options);
+        return result(name, scope, 'healthy', protocol, list.length, instructions, null, null, options, toolNames(list));
     }
     catch (error) {
         const message = redactMcpError(error);
@@ -310,14 +310,21 @@ function timeoutMs(value, fallback) {
     const seconds = Number(value);
     return Math.round(Math.min(30, Math.max(1, Number.isFinite(seconds) ? seconds : fallback)) * 1000);
 }
-function result(server, scope, status, protocol, toolCount, instructions, latency, error, options) {
+function result(server, scope, status, protocol, toolCount, instructions, latency, error, options, toolNames = null) {
     return {
         schema: MCP_HEALTH_SCHEMA, server, scope, status, protocol_version: protocol, tool_count: toolCount,
+        tool_names: toolNames,
         instructions_present: instructions, latency_ms: latency,
         checked_at: options.dependencies?.checkedAt?.() ?? nowIso(),
         public_error: error, log_ref: null
     };
 }
+function toolNames(list) {
+    return [...new Set(list
+            .map((entry) => isRecord(entry) && typeof entry.name === 'string' ? entry.name.trim() : '')
+            .filter(Boolean))]
+        .sort();
+}
 function defaultSpawn(command, args, options) {
     return spawn(command, [...args], {
         ...(options.cwd ? { cwd: options.cwd } : {}),

package/dist/core/migration/migration-transaction-journal.js

@@ -1,9 +1,6 @@
 import path from 'node:path';
 import crypto from 'node:crypto';
 import { appendJsonl, ensureDir, nowIso } from '../fsx.js';
-// Append-only journal of config/runtime migrations performed during an upgrade
-// or `sks doctor --fix`. Every config mutation is recorded with a before/after
-// content hash and the backup path so the change is auditable and reversible.
 export const MIGRATION_JOURNAL_SCHEMA = 'sks.migration-journal.v1';
 export const MIGRATION_JOURNAL_VERSION = '1.20.1';
 export function hashConfigText(text) {
@@ -37,11 +34,6 @@ export function migrationJournalPath(root, opts = {}) {
         : path.join(root, '.sneakoscope', 'reports');
     return path.join(base, `migration-${MIGRATION_JOURNAL_VERSION}-journal.jsonl`);
 }
-/**
- * Append migration events to the journal. Returns the journal path and the
- * built events. A mutation event that recorded no backup is flagged so callers
- * can surface an operator action (rollback unavailable).
- */
 export async function appendMigrationEvents(root, events, opts = {}) {
     const journalPath = migrationJournalPath(root, opts);
     await ensureDir(path.dirname(journalPath));

package/dist/core/mission.js

@@ -207,8 +207,6 @@ export async function findLatestMission(root, opts = {}) {
         const mission = await readJson(path.join(dirPath, 'mission.json'), {}).catch(() => ({}));
         if (mode && mission.mode !== mode)
             return null;
-        // Route scoping is indirect: mission.json never carries a route field, so the
-        // caller must name the route-specific gate artifact to probe for.
         if (route && gateFile) {
             const gate = await readJson(path.join(dirPath, gateFile), null).catch(() => null);
             if (!gate)

package/dist/core/naruto/naruto-active-pool.js

@@ -141,7 +141,6 @@ async function nextCollectableWorkers(active, hardTimeoutMs = 10 * 60 * 1000) {
         ;
         handle.exit.then(() => settled.add(handle), () => settled.add(handle));
     }
-    /* intentional: only racing for settlement timing here — actual outcomes are captured via the .then() handlers above, this catch just prevents an unhandled-rejection warning on the raced promises */
     await Promise.race([
         ...handlesWithExit.map((handle) => handle.exit.catch(() => undefined)),
         delay(1000)
@@ -178,7 +177,6 @@ async function forceCollectTimedOutWorker(handle) {
     };
 }
 function sendSignal(pid, signal) {
-    /* intentional: the pid/process-group may already be dead (ESRCH) by the time this fires — that's the expected common case, not an error */
     if (process.platform !== 'win32') {
         try {
             process.kill(-pid, signal);

package/dist/core/naruto/naruto-concurrency-governor.js

@@ -36,7 +36,6 @@ export function decideNarutoConcurrency(input = {}) {
     const pressure = monitorNarutoResourcePressure(hardware, { activeWorkers: rawSafe, zellijVisiblePaneCap });
     const backpressure = applyNarutoBackpressure(rawSafe, pressure);
     const currentSafeActiveWorkers = Math.max(1, Math.min(rawSafe, backpressure.adjusted_active_workers));
-    // Every mode respects live backpressure. Modes only lower the bounded cap.
     const modeCap = parallelismMode === 'safe'
         ? Math.max(1, Math.ceil(rawSafe * 0.5))
         : parallelismMode === 'balanced'

package/dist/core/naruto/naruto-real-write-proof.js

@@ -1,8 +1,4 @@
 export const NARUTO_REAL_WRITE_PROOF_SCHEMA = 'sks.naruto-real-write-proof.v1';
-// Exact blocker values that legitimately record "work could not be safely
-// split across ≥2 workers" — matched by strict equality only. A substring
-// match here would let any unrelated blocker text mentioning this word
-// silently waive the worker-diversity requirement.
 const UNSPLITTABLE_BLOCKER_VALUES = new Set([
     'native_session_unsplittable_evidence_recorded',
     'unsplittable_write_scope_explicit'