sneakoscope 7.0.2 → 7.0.5

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

@@ -17,19 +17,11 @@ export async function inspectCodePackHeadFreshness(root, packShaInput, opts = {}
         return staleWithCurrentHead(root, null, timeoutMs, fastHead, false, 'invalid_pack_sha');
     if (fastHead === packSha)
         return freshness(true, true, 'exact_head', fastHead, packSha, false, []);
-    // Only the non-blocking hook consumes this cache. Authoritative wiki
-    // validation always replays Git history and never trusts advisory state.
     if (opts.advisoryCache && fastHead) {
         const cached = await readAdvisoryCache(root, packSha, fastHead);
         if (cached)
             return cached;
     }
-    // One common-path Git process returns HEAD plus every committed path after
-    // the pack was generated. Excluding all parents of packSha keeps packSha in
-    // the walk (including a root commit), so its presence proves ancestry. We
-    // keep scanning after the pack marker because a later merge can introduce
-    // sibling-branch commits that Git orders after packSha. `-m` exposes merge
-    // resolution paths and `--no-renames` makes touched paths auditable.
     const history = await runProcess('git', [
         '-c',
         'core.quotepath=true',
@@ -106,8 +98,6 @@ function parseHistory(stdout, packSha) {
         }
         if (activeCommit === packSha)
             continue;
-        // Do not trim Git paths: leading/trailing whitespace is meaningful and
-        // must never be normalized into an allowlisted metadata path.
         for (const changedPath of pathText.split('\t')) {
             if (!changedPath || seenPaths.has(changedPath))
                 continue;

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

@@ -41,7 +41,6 @@ export function buildCodePack(root, index, tokenBudget = DEFAULT_CODE_PACK_TOKEN
 }
 function buildEntryForModule(card) {
     const citations = collectCitations(card);
-    // openwiki principle: an entry with no real repository citation is worse than no entry at all
     if (!citations.length)
         return null;
     const text = summarizeModule(card);
@@ -102,7 +101,6 @@ function summarizeDependencies(dependencyEdges) {
     return `Depends on: ${preview.join(', ')}${suffix}.`;
 }
 function computeTrustScore(card) {
-    // more citable surface (entry points, real exports) correlates with a more reliably summarizable module
     let score = 0.5;
     if (card.entry_points.length > 0)
         score += 0.2;

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

@@ -191,7 +191,6 @@ function listFiles(root, start) {
             entries = fs.readdirSync(dir, { withFileTypes: true });
         }
         catch (error) {
-            // dir can vanish or become unreadable between stack push and pop (TOCTOU) — contribute zero files, not a crash
             if (isMissingOrInaccessible(error))
                 continue;
             throw error;

package/dist/core/triwiki/triwiki-proof-bank.js

@@ -117,7 +117,6 @@ function atomicWriteJson(file, value) {
             fs.fsyncSync(fd);
         }
         catch {
-            // fsync can be unavailable on some virtual filesystems; rename remains atomic.
         }
     }
     finally {

package/dist/core/triwiki-attention.js

@@ -237,20 +237,10 @@ function uniqueAttentionRows(rows = [], max = 4) {
     }
     return out;
 }
-/** Ranks code-pack entries (LLM-consumable, source-cited codebase summaries — see
- * src/core/triwiki/code-pack.ts) by trust_score into a dedicated attention sub-budget,
- * independent of the policy-claim RGBA/geometric selection above: code entries carry
- * no meaningful mission-coordinate proximity, so competing them against policy claims
- * for the same fixed slot budget would make their appearance arbitrary. Each surviving
- * high-trust, clean entry becomes a use_first row (bare id, no fabricated RGBA).
- * Lower-trust or wrongness-linked entries are hydrate-only so negative evidence can
- * never be promoted into the high-trust fast path. Citation-backed hydrate rows tell
- * consumers which real files must be read before relying on a summary. */
 function codePackAttentionRows(codePackEntries = [], tokenBudget = 2000, wrongnessByModule = {}) {
     const moduleWrongness = (entryId) => Number(wrongnessByModule[String(entryId || '').replace(/^code:/, '')] || 0);
     const sorted = [...(codePackEntries || [])]
         .filter((entry) => entry && typeof entry.id === 'string')
-        // Modules SKS has been wrong about before are worth re-reading first, then rank by trust.
         .sort((a, b) => (moduleWrongness(b.id) - moduleWrongness(a.id)) || (Number(b.trust_score || 0) - Number(a.trust_score || 0)));
     const useFirst = [];
     const hydrateFirst = [];

package/dist/core/triwiki-provenance.js

@@ -56,11 +56,6 @@ function authoritativeCitations(pack) {
         .map((value) => value.trim());
     return [...new Set(normalized)].sort((a, b) => a.localeCompare(b));
 }
-/**
- * Bounded byte manifest for the exact local hydration citations carried by a
- * context pack. Runtime/generated state is intentionally excluded so ordinary
- * mission/report churn cannot invalidate otherwise-current source memory.
- */
 export function buildTriWikiSourceManifest(pack, root) {
     const citations = authoritativeCitations(pack);
     const includedCitations = [];

package/dist/core/triwiki-runtime.js

@@ -2,10 +2,6 @@ import path from 'node:path';
 import { ensureDir, readJson, writeJsonAtomic } from './fsx.js';
 import { validateWikiCoordinateIndex } from './wiki-coordinate.js';
 import { validateTriWikiContextPackProvenance } from './triwiki-provenance.js';
-// Inference-path TriWiki consumption. Routes/the agent kernel READ the deployed
-// context pack written by `sks wiki refresh|pack` (the SSOT); they never rebuild
-// it on the hot path. This is the seam that turns the TriWiki engine from an
-// advisory prompt note into an actually-consulted, proof-referenced context source.
 export const TRIWIKI_CONTEXT_PACK_REL = '.sneakoscope/wiki/context-pack.json';
 export const TRIWIKI_RUNTIME_SCHEMA = 'sks.triwiki-runtime-context.v1';
 function emptyContext(file, warning = 'no_triwiki_context_pack (run `sks wiki refresh` to populate the project memory pack)') {
@@ -23,11 +19,6 @@ function emptyContext(file, warning = 'no_triwiki_context_pack (run `sks wiki re
         warning
     };
 }
-/**
- * Load the deployed TriWiki context pack for a project root. Read-only; tolerant
- * of an absent/corrupt pack (returns present:false + a warning so the route still
- * runs as a graceful fallback). Never invokes pack rebuild or any model call.
- */
 export async function loadTriWikiRuntimeContext(root) {
     const file = path.join(path.resolve(root), TRIWIKI_CONTEXT_PACK_REL);
     let pack = null;
@@ -69,7 +60,6 @@ export async function loadTriWikiRuntimeContext(root) {
         warning: null
     };
 }
-/** Compact instruction block injected into read-only agents / route additionalContext. */
 export function triWikiContextBlock(ctx) {
     if (!ctx.present)
         return `TriWiki unavailable: ${ctx.warning || 'context pack missing or invalid'}; do not rely on cached project memory.`;
@@ -82,7 +72,6 @@ export function triWikiContextBlock(ctx) {
         hyd.length ? `hydrate_first (verify source before risky/user-visible actions): ${hyd.join(', ')}` : 'hydrate_first: none'
     ].join('\n');
 }
-/** Proof fields recorded by the kernel/route so its proof references the wiki it acted on. */
 export function triWikiProofRecord(ctx) {
     return {
         triwiki_context_consulted: ctx.present,
@@ -95,7 +84,6 @@ export function triWikiProofRecord(ctx) {
         warning: ctx.warning
     };
 }
-/** Persist the consulted TriWiki context as a per-mission proof artifact. */
 export async function writeTriWikiContextArtifact(ledgerRoot, ctx) {
     const file = path.join(path.resolve(ledgerRoot), 'agent-triwiki-context.json');
     await ensureDir(path.dirname(file));

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

@@ -65,10 +65,6 @@ async function writeWrongnessLedgerUnlocked(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);
-    // 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;
@@ -115,9 +111,6 @@ export async function resolveWrongnessRecord(root, id, reason = 'Resolved after
         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) => {

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

@@ -149,9 +149,6 @@ export function createWrongnessRecord(input = {}) {
         ...(row.compiled_rule_id === undefined ? {} : { compiled_rule_id: stringOrNull(row.compiled_rule_id) })
     };
 }
-/** Best-effort module attribution from the wrongness's linked files. Excludes the
- * 'unknown' sentinel moduleIdsForPath returns for unmapped paths, so a record only
- * carries module_ids when at least one file maps to a real TriWiki module. */
 function moduleIdsForWrongness(files) {
     const ids = new Set();
     for (const file of files) {

package/dist/core/trust-kernel/trust-report.js

@@ -54,13 +54,6 @@ export async function latestTrustReport(root, missionArg = 'latest') {
         return staleTrustReport(report, temporalIssues);
     }
     if (!proof) {
-        // Persist this computed report even though it's a blocked result: `trust report`
-        // is expected to leave a durable trust-report.json behind for anyone (a human or
-        // a later `sks trust report <mission>` call) to inspect, the same way the
-        // completion-proof-present path below does via writeTrustArtifactsForProof(). An
-        // in-memory-only "blocked" result that vanishes after this call returns is
-        // surprising and was the reason `sks trust report latest --json` could exit 0
-        // with a blocked status yet leave no artifact on disk.
         const report = {
             schema: TRUST_REPORT_SCHEMA,
             ...trustKernelMetadata(),

package/dist/core/update/update-migration-state.js

@@ -1,7 +1,7 @@
 import fsp from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { ensureDir, exists, globalSksRoot, nowIso, packageRoot, PACKAGE_VERSION, projectRoot, readJson, readText, runProcess, sha256, which, writeJsonAtomic, writeReceiptRotated, writeTextAtomic } from '../fsx.js';
+import { ensureDir, exists, globalSksRoot, nowIso, packageRoot, PACKAGE_VERSION, projectRoot, readJson, readText, runProcess, sameFilesystemPath, sha256, which, writeJsonAtomic, writeReceiptRotated, writeTextAtomic } from '../fsx.js';
 import { MANAGED_ASSET_VERSION } from '../managed-assets/managed-assets-manifest.js';
 import { enforceRetention } from '../retention.js';
 import { COMMANDS } from '../../cli/command-registry.js';
@@ -83,8 +83,6 @@ export async function writePendingUpdateMigration(input) {
     return receipt;
 }
 export async function clearPendingUpdateMigration() {
-    // v2 keeps a persistent installation epoch; project receipts are compared
-    // independently and one project must not consume global migration state.
 }
 export async function writeProjectUpdateMigrationReceipt(input) {
     const receiptPath = projectUpdateMigrationReceiptPath(input.root);
@@ -197,6 +195,11 @@ export async function runUpdateRetentionCleanup(root, source = 'update-migration
     }
 }
 const UPDATE_MIGRATION_STAGES = [
+    {
+        id: 'other-harness-cleanup',
+        min_from_version: '0.0.0',
+        run: runOtherHarnessCleanupStage
+    },
     {
         id: 'current-public-surface-reconcile',
         min_from_version: '0.0.0',
@@ -233,20 +236,53 @@ const UPDATE_MIGRATION_STAGES = [
         run: runReceiptRotationStage
     }
 ];
+async function runOtherHarnessCleanupStage(root) {
+    const { cleanupOtherHarnessConflicts } = await import('../harness-conflicts.js');
+    const cleanup = await cleanupOtherHarnessConflicts(root);
+    const blockers = cleanup.ok
+        ? []
+        : [
+            ...(cleanup.errors || []).map((row) => `other_harness_cleanup_error:${row.path}`),
+            ...((cleanup.remaining || []).map((row) => `other_harness_remaining:${row.path}`))
+        ];
+    return {
+        ok: blockers.length === 0,
+        status: blockers.length ? 'failed' : (cleanup.cleaned.length ? 'ok' : 'ok'),
+        actions: cleanup.cleaned.length ? ['quarantined_other_harness_conflicts'] : ['other_harness_surface_clean'],
+        blockers,
+        warnings: [],
+        detail: {
+            cleaned_count: cleanup.cleaned.length,
+            remaining_count: (cleanup.remaining || []).length,
+            error_count: (cleanup.errors || []).length,
+            run_id: cleanup.run_id
+        }
+    };
+}
 async function runCurrentPublicSurfaceReconcileStage(root) {
-    const [{ runDoctorCommandAliasCleanup }, { reconcileRetiredAgentRoleResidue }] = await Promise.all([
+    const [{ runDoctorCommandAliasCleanup }, { reconcileRetiredAgentRoleResidue }, { migrateSksProfilesToPerFile }] = await Promise.all([
         import('../doctor/command-alias-cleanup.js'),
-        import('../agents/agent-role-config.js')
+        import('../agents/agent-role-config.js'),
+        import('../auto-review.js')
     ]);
     const home = path.resolve(process.env.HOME || os.homedir());
     const globalRuntimeRoot = path.resolve(process.env.SKS_GLOBAL_ROOT || path.join(home, '.sneakoscope-global'));
-    const [publicSurface, retiredRoles] = await Promise.all([
-        runDoctorCommandAliasCleanup({ root, home, globalRuntimeRoot, fix: true }),
-        reconcileRetiredAgentRoleResidue({ root, home, globalRuntimeRoot, fix: true })
-    ]);
+    const publicSurface = await runDoctorCommandAliasCleanup({ root, home, globalRuntimeRoot, fix: true });
+    const retiredRoles = await reconcileRetiredAgentRoleResidue({ root, home, globalRuntimeRoot, fix: true });
+    const profileMigration = await migrateSksProfilesToPerFile({ env: process.env }).catch((err) => ({
+        error: err?.message || String(err),
+        retired_profile_table_count: 0,
+        retired_profile_file_removed_count: 0
+    }));
+    const remainingCount = Number(publicSurface.cleanup?.remaining_count || 0)
+        + Number(publicSurface.cleanup?.managed_runtime?.remaining_managed_artifact_count || 0)
+        + Number(publicSurface.cleanup?.project_guidance?.remaining_count || 0)
+        + retiredRoles.remaining_count;
     const blockers = [
         ...(publicSurface.ok === true ? [] : ['public_surface_reconcile_failed']),
-        ...(retiredRoles.ok === true ? [] : ['retired_agent_role_reconcile_failed'])
+        ...(retiredRoles.ok === true ? [] : ['retired_agent_role_reconcile_failed']),
+        ...(profileMigration.error ? [`retired_profile_migration_failed:${profileMigration.error}`] : []),
+        ...(remainingCount > 0 ? [`public_surface_remaining:${remainingCount}`] : [])
     ];
     return {
         ok: blockers.length === 0,
@@ -263,10 +299,9 @@ async function runCurrentPublicSurfaceReconcileStage(root) {
             quarantined_guidance_collision_count: Number(publicSurface.cleanup?.project_guidance?.preserved_user_file_count || 0),
             removed_retired_role_count: retiredRoles.removed_count,
             quarantined_retired_role_collision_count: retiredRoles.quarantined_user_collision_count,
-            remaining_count: Number(publicSurface.cleanup?.remaining_count || 0)
-                + Number(publicSurface.cleanup?.managed_runtime?.remaining_managed_artifact_count || 0)
-                + Number(publicSurface.cleanup?.project_guidance?.remaining_count || 0)
-                + retiredRoles.remaining_count
+            retired_profile_table_count: Number(profileMigration.retired_profile_table_count || 0),
+            retired_profile_file_removed_count: Number(profileMigration.retired_profile_file_removed_count || 0),
+            remaining_count: remainingCount
         }
     };
 }
@@ -341,10 +376,23 @@ async function runSessionStateSplitStage(root) {
 }
 async function runSkillsReconcileStage(root) {
     const home = path.resolve(process.env.HOME || os.homedir());
-    const global = await reconcileSkills({ targetDir: path.join(home, '.agents', 'skills'), scope: 'global', fix: true })
-        .catch((err) => ({ ok: false, error: err?.message || String(err) }));
-    const project = await reconcileSkills({ targetDir: path.join(root, '.agents', 'skills'), scope: 'project', fix: true })
+    const globalTarget = path.resolve(home, '.agents', 'skills');
+    const projectTarget = path.resolve(root, '.agents', 'skills');
+    const global = await reconcileSkills({ targetDir: globalTarget, scope: 'global', fix: true })
         .catch((err) => ({ ok: false, error: err?.message || String(err) }));
+    const sameSkillRoot = await sameFilesystemPath(projectTarget, globalTarget);
+    const project = sameSkillRoot
+        ? {
+            schema: 'sks.skill-reconcile.v1',
+            ok: true,
+            scope: 'project',
+            target_dir: projectTarget,
+            fix: true,
+            skipped: true,
+            reason: 'same_as_authoritative_global_skill_root'
+        }
+        : await reconcileSkills({ targetDir: projectTarget, scope: 'project', fix: true })
+            .catch((err) => ({ ok: false, error: err?.message || String(err) }));
     const globalRemaining = Number(global.retired_residue?.remaining_count || 0);
     const projectRemaining = Number(project.retired_residue?.remaining_count || 0);
     const blockers = [
@@ -356,7 +404,10 @@ async function runSkillsReconcileStage(root) {
     return {
         ok: blockers.length === 0,
         status: blockers.length ? 'failed' : 'ok',
-        actions: ['reconciled_global_skills', 'reconciled_project_skills'],
+        actions: [
+            'reconciled_global_skills',
+            sameSkillRoot ? 'skipped_project_skills_same_as_global' : 'reconciled_project_skills'
+        ],
         blockers,
         warnings: [],
         detail: {
@@ -370,19 +421,27 @@ async function runSkillsReconcileStage(root) {
     };
 }
 async function runMenubarRetargetStage(root) {
-    const actionScript = path.join(os.homedir(), '.codex', 'sks-menubar', 'sks-menubar-action.sh');
+    const installDir = path.join(os.homedir(), '.codex', 'sks-menubar');
+    const actionScript = path.join(installDir, 'sks-menubar-action.sh');
+    const buildStamp = path.join(installDir, 'build-stamp.json');
     const text = await readText(actionScript, null);
     if (typeof text !== 'string')
         return { ok: true, status: 'ok', actions: ['menubar_action_script_absent'], blockers: [], warnings: [] };
     const desired = path.join(packageRoot(), 'dist', 'bin', 'sks.js');
     const line = `SKS_ENTRY='${desired.replace(/'/g, `'\\''`)}'`;
     const actions = [];
+    const stampedGeneration = await exists(buildStamp);
     const next = /^\s*SKS_ENTRY\s*=.*$/m.test(text)
         ? text.replace(/^\s*SKS_ENTRY\s*=.*$/m, line)
         : `${line}\n${text}`;
     if (next !== text) {
-        await writeTextAtomic(actionScript, next);
-        actions.push('retargeted_menubar_action_script');
+        if (stampedGeneration) {
+            actions.push('deferred_menubar_retarget_to_transactional_rebuild');
+        }
+        else {
+            await writeTextAtomic(actionScript, next);
+            actions.push('retargeted_legacy_menubar_action_script');
+        }
     }
     const stat = await fsp.stat(actionScript).catch(() => null);
     if (!stat || (stat.mode & 0o111) === 0) {
@@ -395,30 +454,45 @@ async function runMenubarRetargetStage(root) {
         actions: actions.length ? actions : ['menubar_action_script_current'],
         blockers: [],
         warnings: [],
-        detail: { action_script: actionScript }
+        detail: {
+            action_script: actionScript,
+            build_stamp_present: stampedGeneration,
+            retarget_deferred: stampedGeneration && next !== text
+        }
     };
 }
 async function runConfigFastModeNormalizeStage() {
+    const { reconcileRetiredSksConfigText } = await import('../auto-review.js');
     const configPath = path.join(os.homedir(), '.codex', 'config.toml');
     const text = await readText(configPath, null);
     if (typeof text !== 'string')
         return { ok: true, status: 'ok', actions: ['codex_config_absent'], blockers: [], warnings: [] };
     const normalized = normalizeLegacyFastModeConfigForUpdate(text);
-    if (normalized.text === ensureTrailingNewline(text)) {
+    const retired = reconcileRetiredSksConfigText(normalized.text);
+    const nextText = ensureTrailingNewline(retired.text);
+    const actions = [
+        ...normalized.actions,
+        ...(retired.detected_count > 0 ? ['stripped_retired_sks_config_profiles_and_policies'] : [])
+    ];
+    if (nextText === ensureTrailingNewline(text)) {
         return {
             ok: true,
             status: 'ok',
-            actions: ['fastmode_config_current'],
+            actions: actions.length ? actions : ['fastmode_config_current'],
             blockers: [],
             warnings: [],
-            detail: { config_path: configPath, default_profile: normalized.defaultProfile }
+            detail: {
+                config_path: configPath,
+                default_profile: normalized.defaultProfile,
+                retired_config_detected_count: retired.detected_count
+            }
         };
     }
     let guardResult = null;
     guardResult = await writeCodexConfigGuarded({
         configPath,
         before: text,
-        mutate: () => normalized.text,
+        mutate: () => nextText,
         cause: 'project-update-fastmode-normalize',
         backupTag: 'project-update-fastmode-normalize',
         preserveFastUiKeys: true
@@ -430,16 +504,26 @@ async function runConfigFastModeNormalizeStage() {
             actions: ['normalize_fastmode_config_blocked'],
             blockers: [`codex_config_guard:${guardResult.status}`],
             warnings: [],
-            detail: { config_path: configPath, default_profile: normalized.defaultProfile, guard: guardResult }
+            detail: {
+                config_path: configPath,
+                default_profile: normalized.defaultProfile,
+                retired_config_detected_count: retired.detected_count,
+                guard: guardResult
+            }
         };
     }
     return {
         ok: true,
         status: 'ok',
-        actions: normalized.actions.length ? normalized.actions : ['fastmode_config_current'],
+        actions: actions.length ? actions : ['fastmode_config_current'],
         blockers: [],
         warnings: [],
-        detail: { config_path: configPath, default_profile: normalized.defaultProfile, guard: guardResult }
+        detail: {
+            config_path: configPath,
+            default_profile: normalized.defaultProfile,
+            retired_config_detected_count: retired.detected_count,
+            guard: guardResult
+        }
     };
 }
 async function runHookTrustRefreshStage(root) {
@@ -500,11 +584,6 @@ function insertTopLevelTomlKey(text, line) {
     return `${raw.slice(0, firstTable).trimEnd()}\n${line}\n\n${raw.slice(firstTable).trimStart()}`.trim() + '\n';
 }
 function normalizeLegacyFastModeConfigForUpdate(text) {
-    // 2026-07 ChatGPT desktop merge: default_profile, [user.fast_mode], and
-    // [profiles.<name>] tables left the Codex config schema. This migration now
-    // STRIPS the stamps older SKS versions wrote instead of normalizing them, and
-    // preserves a legacy "fast default" semantically by writing the documented
-    // top-level service_tier = "fast" in their place.
     let next = String(text || '');
     const actions = [];
     const misplaced = tomlTableString(next, 'user.fast_mode', 'default_profile');
@@ -652,17 +731,9 @@ export async function ensureCurrentMigrationBeforeCommand(input) {
     if (input.skipMigrationGate === true || commandSkipsMigrationGate(command)) {
         return { ...empty, ok: true, status: 'skipped', receipt: null, doctor: null, failed_stage_id: null, blockers: [], warnings: [`skip_migration_gate_command:${command}`] };
     }
-    // projectRoot() falls back to the raw cwd when no project marker is found.
-    // launchd-spawned callers (the SKS menu bar app) run with cwd=/ — there is
-    // no project to migrate there, and proceeding would mkdir /.sneakoscope and
-    // crash the whole command before it starts.
     if (root === path.parse(root).root) {
         return { ...empty, ok: true, status: 'skipped', receipt: null, doctor: null, failed_stage_id: null, blockers: [], warnings: ['no_project_workspace_at_filesystem_root'] };
     }
-    // A git repository is not automatically an SKS project. Global Codex skills
-    // (including DFix) may run in ordinary repositories, and route-local state or
-    // a stale failed migration receipt can leave a partial `.sneakoscope` folder
-    // behind. Only strong installed-project markers authorize project migration.
     if (!(await hasSksProjectMigrationMarker(root))) {
         return { ...empty, ok: true, status: 'skipped', receipt: null, doctor: null, failed_stage_id: null, blockers: [], warnings: ['non_sks_workspace_migration_gate_skipped'] };
     }
@@ -970,10 +1041,6 @@ export async function resolveInstalledSksEntrypoint(input = {}) {
     }
     return which('sks');
 }
-// 20차 P2-2: was 20s — --help now bypasses this gate entirely (cli/router.ts),
-// so this timeout only affects commands that genuinely need the migration
-// gate; 5s is enough to cooperate with a sibling in-flight migration without
-// making every gated command absorb a 20s worst case.
 const MIGRATION_LOCK_WAIT_MS = 5_000;
 const MIGRATION_LOCK_POLL_MS = 150;
 const MIGRATION_LOCK_PROGRESS_INTERVAL_MS = 1_000;
@@ -986,8 +1053,6 @@ async function withUpdateMigrationLock(root, base, fn, options = {}) {
         await ensureDir(path.dirname(lockPath));
     }
     catch (err) {
-        // An unwritable root (read-only mount, cwd outside any workspace) must fail
-        // the gate with a reportable blocker, not crash the whole CLI dispatch.
         return { ...base, ok: false, status: 'blocked', receipt: null, doctor: null, failed_stage_id: 'migration-lock', blockers: [`update_migration_lock_dir_unwritable:${err?.message || String(err)}`], warnings: [] };
     }
     const recheck = options.recheck ?? null;
@@ -1004,19 +1069,15 @@ async function withUpdateMigrationLock(root, base, fn, options = {}) {
             if (err?.code !== 'EEXIST') {
                 return { ...base, ok: false, status: 'blocked', receipt: null, doctor: null, failed_stage_id: 'migration-lock', blockers: [`update_migration_lock_error:${err?.message || String(err)}`], warnings: [] };
             }
-            // The lock is held by a concurrent process. Cooperate instead of failing fast:
-            // 1) a sibling may have already completed the migration we need.
             if (recheck) {
                 const done = await recheck();
                 if (done)
                     return done;
             }
-            // 2) reap a genuinely stale lock (dead holder or older than the stale threshold).
             if (!reapedStale && await removeStaleMigrationLock(lockPath)) {
                 reapedStale = true;
                 continue;
             }
-            // 3) wait for the in-flight holder to finish, then retry acquisition.
             if (Date.now() < deadline) {
                 const now = Date.now();
                 if (now - lastProgressAt >= MIGRATION_LOCK_PROGRESS_INTERVAL_MS) {
@@ -1026,7 +1087,6 @@ async function withUpdateMigrationLock(root, base, fn, options = {}) {
                 await delay(MIGRATION_LOCK_POLL_MS);
                 continue;
             }
-            // 4) gave up waiting on a live holder.
             return { ...base, ok: false, status: 'blocked', receipt: null, doctor: null, failed_stage_id: 'migration-lock', blockers: ['update_migration_lock_held'], warnings: [] };
         }
         try {
@@ -1044,14 +1104,6 @@ async function withUpdateMigrationLock(root, base, fn, options = {}) {
 }
 const DOCTOR_MIGRATION_REPORT_KEEP_COUNT = 10;
 const DOCTOR_MIGRATION_REPORT_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
-// A now-unused legacy naming scheme (doctor-migration-<epoch>.json per run,
-// one per migration-gate doctor invocation) left ~80 files/several MB of
-// dead weight in .sneakoscope/update/ with nothing ever removing them
-// (20차 P2-5c) — the current code writes a single fixed doctor-migration.json
-// instead, but any leftovers from before that change, or from any other
-// path that reintroduces per-run naming, are pruned here: keep the most
-// recent DOCTOR_MIGRATION_REPORT_KEEP_COUNT, and nothing older than
-// DOCTOR_MIGRATION_REPORT_MAX_AGE_MS regardless of count.
 async function pruneLegacyDoctorMigrationReports(root) {
     const dir = path.join(root, '.sneakoscope', 'update');
     const entries = await fsp.readdir(dir, { withFileTypes: true }).catch(() => []);

package/dist/core/update-check.js

@@ -784,12 +784,6 @@ export function menuBarInstallIsTerminalUncertain(result) {
 }
 async function runUpdateGlobalSkillsReconcile(stage, opts = {}) {
     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
-    // an in-process reconcile would overwrite the manifest the new binary's
-    // migration doctor just wrote and make final self-verification report
-    // skills_manifest stale forever. Delegate to the freshly installed package.
     if (opts.newPackageRoot) {
         const moduleHref = pathToFileURL(path.join(opts.newPackageRoot, 'dist', 'core', 'init', 'skills.js')).href;
         const script = [
@@ -810,7 +804,7 @@ async function runUpdateGlobalSkillsReconcile(stage, opts = {}) {
                 parsed = JSON.parse(line);
                 break;
             }
-            catch { /* not the JSON result line */ }
+            catch { }
         }
         const ok = run.code === 0 && parsed?.ok !== false && !parsed?.error;
         stage('global_skills_reconcile', ok, ok ? 'reconciled' : 'failed', {
@@ -844,9 +838,6 @@ async function runUpdateNativeCapabilitySetup(stage, opts) {
     }
     const root = opts.root;
     const moduleHref = (rel) => pathToFileURL(path.join(opts.newPackageRoot, 'dist', 'core', 'doctor', rel)).href;
-    // Same as global_skills_reconcile above: run the newly installed package's own
-    // modules in a subprocess rather than in-process, so an old (pre-update) driver
-    // binary never runs post-update repair logic with stale compiled-in behavior.
     const script = [
         `const [{ repairCodexImagegen }, { repairComputerUse }, { repairBrowserUse }] = await Promise.all([import(${JSON.stringify(moduleHref('imagegen-repair.js'))}), import(${JSON.stringify(moduleHref('computer-use-repair.js'))}), import(${JSON.stringify(moduleHref('browser-use-repair.js'))})]);`,
         `const root = ${JSON.stringify(root)};`,
@@ -867,13 +858,10 @@ async function runUpdateNativeCapabilitySetup(stage, opts) {
             parsed = JSON.parse(line);
             break;
         }
-        catch { /* not the JSON result line */ }
+        catch { }
     }
     const summarize = (r) => (r?.recovered === true || r?.ok === true ? 'ok' : r?.attempted ? 'blocked' : 'not-needed');
     const ok = run.code === 0 && Boolean(parsed);
-    // A repair reporting 'blocked' (e.g. no verified CLI subcommand for a plugin
-    // install) is a valid, honest terminal state for this stage, not a stage
-    // failure — the update itself must not be blocked on a manual-only step.
     stage('native_capability_setup', ok, ok ? 'completed' : 'failed', {
         via: 'new_package_binary',
         summary: ok