sneakoscope 7.0.2 → 7.0.3

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);
@@ -341,10 +339,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 +367,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: {
@@ -500,11 +514,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 +661,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 +971,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 +983,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 +999,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 +1017,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 +1034,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

package/dist/core/version-manager.js

@@ -358,6 +358,8 @@ async function syncSourcePackageVersion(root, version) {
         {
             rel: 'docs/release-readiness.md',
             replace: (text) => text
+                .replace(/^# SKS \d+\.\d+\.\d+ Release Readiness$/m, `# SKS ${version} Release Readiness`)
+                .replace(/(`sneakoscope`\r?\n)\d+\.\d+\.\d+\. The current package version on this branch is \d+\.\d+\.\d+\./m, (_match, prefix) => `${prefix}${version}. The current package version on this branch is ${version}.`)
                 .replace(/^SKS \d+\.\d+\.\d+ is ready/m, `SKS ${version} is ready`)
                 .replace(/^Codex 0\.142 references later in this document are historical release records and cannot authorize the \d+\.\d+\.\d+ release\./m, `Codex 0.142 references later in this document are historical release records and cannot authorize the ${version} release.`)
                 .replace(/^\d+\.\d+\.\d+ release readiness requires/m, `${version} release readiness requires`)

package/dist/core/version.js

@@ -1 +1 @@
-export const PACKAGE_VERSION = '7.0.2';
+export const PACKAGE_VERSION = '7.0.3';

package/dist/core/work-order-ledger.js

@@ -89,11 +89,6 @@ export function updateWorkOrderItem(ledger, id, patch = {}) {
         })
     };
 }
-/**
- * Parses a free-form work-order prompt into WO-001..N ledger items (via
- * promptRequirementItems) and persists the ledger at mission creation time,
- * so every item is registered verbatim before any execution starts.
- */
 export async function createAndWriteWorkOrderLedgerForPrompt(dir, { missionId, route, prompt } = {}) {
     const parsed = semanticSliceRequirementItems(String(prompt || '')) || promptRequirementItems(String(prompt || ''));
     const { items, truncated } = parsed;
@@ -264,22 +259,10 @@ function stripSliceMarker(text) {
         .replace(/\s+/g, ' ')
         .trim();
 }
-/**
- * Closes out every item in a mission's ledger to a terminal state once the
- * route's own gate has decided ok/not-ok, so evaluateStop's coverage gate
- * (which blocks stop while any item sits in 'pending') can never wait
- * forever: an item is either verified (route succeeded) or honestly
- * blocked (route failed, real blockers recorded), never left hanging.
- * This is coarser than true per-item tracking, but it closes the loop.
- */
 export async function closeWorkOrderLedgerForRouteResult(dir, { ok, blockers = [], allowAttachmentBulkClose = false }) {
     const ledger = await readWorkOrderLedger(dir);
     if (!ledger || !Array.isArray(ledger.items) || ledger.items.length === 0)
         return null;
-    // Attachment-backed ledgers can represent a release work order with many
-    // independently authorized and independently verified requirements. A
-    // single route gate is not evidence that every attachment slice passed (or
-    // that post-main/2FA work occurred), so preserve per-item truth by default.
     if (!allowAttachmentBulkClose && ledger.items.some((item) => item?.source?.type === 'attachment')) {
         return ledger;
     }

package/dist/core/zellij/zellij-clipboard-config.js

@@ -1,22 +1,9 @@
 import path from 'node:path';
 import { ensureDir, nowIso, writeTextAtomic } from '../fsx.js';
-// Single source of truth for the Zellij clipboard pipeline used by `sks --mad`
-// (and any other SKS-launched Zellij session). By default Zellij copies via the
-// OSC 52 escape sequence, which several macOS terminals (Terminal.app always,
-// some iTerm2 configs) silently drop. Setting copy_command="pbcopy" keeps
-// Zellij's copy action wired to the macOS clipboard.
-//
-// Keep Zellij mouse_mode on by default so trackpad/wheel gestures are handled by
-// Zellij pane scrollback instead of being translated into prompt-history input
-// inside the focused Codex TUI. Copy remains wired through copy_command/pbcopy
-// plus copy_on_select; users who need terminal-native selection can hold Shift
-// or opt out with SKS_ZELLIJ_MOUSE_MODE=0.
 export const ZELLIJ_CLIPBOARD_CONFIG_SCHEMA = 'sks.zellij-clipboard-config.v1';
-/** Pick the platform-correct clipboard command. macOS is the primary target. */
 export function resolveCopyCommand(platform = process.platform, env = process.env) {
     if (platform === 'darwin')
         return 'pbcopy';
-    // Wayland sessions prefer wl-copy; fall back to xclip on X11. pbcopy is darwin-only.
     if (env.WAYLAND_DISPLAY)
         return 'wl-copy';
     return 'xclip -selection clipboard';
@@ -24,7 +11,6 @@ export function resolveCopyCommand(platform = process.platform, env = process.en
 function kdlString(value) {
     return JSON.stringify(String(value || ''));
 }
-/** Render a minimal, valid Zellij config.kdl that enables clipboard copy. */
 export function buildZellijClipboardKdl(cfg) {
     return [
         '// Generated by Sneakoscope (sks) so launched Zellij sessions copy to the OS clipboard.',
@@ -49,10 +35,6 @@ export async function writeZellijClipboardConfig(root, missionId, platform = pro
         copy_clipboard,
         copy_on_select,
         mouse_mode,
-        // Appended AFTER `--default-layout <path>` in the create command. Zellij treats
-        // --copy-command as mutually exclusive with --copy-clipboard (OSC52 target), so
-        // only pass the command and copy-on-select flags on the CLI. The generated KDL
-        // still records copy_clipboard for config-file consumers that use OSC52.
         optionFlags: ['--copy-command', copy_command, '--copy-on-select', String(copy_on_select), '--mouse-mode', String(mouse_mode)],
         config_path,
         generated_at: nowIso()

package/dist/core/zellij/zellij-lane-renderer.js

@@ -3,26 +3,14 @@ import { open, readdir, stat } from 'node:fs/promises';
 import { appendJsonl, ensureDir, exists, nowIso, readJson, readText, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
 import { resolveFastModePolicy } from '../agents/fast-mode-policy.js';
 export const ZELLIJ_LANE_RENDER_SCHEMA = 'sks.zellij-lane-render.v1';
-// Default render width. Zellij panes are commonly 80/100/120 columns; the frame
-// must stay readable (no wraps, no overflow) across that range.
 export const ZELLIJ_LANE_DEFAULT_WIDTH = 80;
 export const ZELLIJ_LANE_MAX_BLOCKERS = 3;
-// Footer command palette. Every `sks ...` token here MUST be a real command
-// (enforced by scripts/zellij-ui-design-check.mjs). `Ctrl+q` is a Zellij keybind.
 export const ZELLIJ_LANE_FOOTER_KEYS = [
     'Ctrl+q detach',
     'sks doctor --fix',
     'sks zellij status',
     'sks naruto status'
 ];
-// Canonical lane section sets (1.20.2 Area 5.2).
-// ZELLIJ_LANE_SECTIONS is the full composed-frame superset the UI-design fixture
-// gate enforces. ZELLIJ_SCREEN_SCRAPEABLE_SECTIONS is the strict SUBSET that the
-// runtime screen-proof reliably scrapes from a live terminal — the 7 extra
-// sections (Fast, Codex child, Work, Patch, Lease, Protected, Rollback) are
-// detail rows that may be elided/wrapped on a real pane, so requiring them in
-// the live screen-proof would make it flaky. The subset relationship is asserted
-// by zellij:doctor-readiness so the two layers can never silently diverge.
 export const ZELLIJ_LANE_SECTIONS = [
     'SKS Lane', 'Mission', 'Mode', 'Fast', 'Workers', 'Codex child', 'Work', 'Current',
     'Queue', 'Patch', 'Safety', 'Lease', 'Protected', 'Rollback', 'Blockers', 'Reports', 'Keys:'
@@ -31,10 +19,10 @@ export const ZELLIJ_SCREEN_SCRAPEABLE_SECTIONS = [
     'SKS Lane', 'Mission', 'Mode', 'Workers', 'Current', 'Queue', 'Safety', 'Blockers', 'Reports', 'Keys:'
 ];
 const STATUS_COLORS = {
-    ok: '', // green
-    active: '', // cyan
-    warning: '', // yellow
-    blocked: '' // red
+    ok: '',
+    active: '',
+    warning: '',
+    blocked: ''
 };
 const RESET = '';
 function colorEnabled(opts) {
@@ -49,8 +37,6 @@ function paint(text, status, enabled) {
         return text;
     return `${STATUS_COLORS[status]}${text}${RESET}`;
 }
-// Shorten a string to fit `max` visible chars, keeping head and tail (so long
-// file paths stay recognizable). Pure on the visible (ANSI-free) string.
 export function middleEllipsis(value, max) {
     const text = String(value ?? '');
     if (max <= 1)
@@ -59,7 +45,7 @@ export function middleEllipsis(value, max) {
         return text;
     if (max <= 3)
         return text.slice(0, max);
-    const keep = max - 1; // room for the ellipsis char
+    const keep = max - 1;
     const head = Math.ceil(keep / 2);
     const tail = Math.floor(keep / 2);
     return `${text.slice(0, head)}…${text.slice(text.length - tail)}`;
@@ -78,15 +64,6 @@ function statusFor(value) {
         return 'ok';
     return null;
 }
-/**
- * Compose the lane frame from a plain view object. Pure (no IO) so gates can
- * render it deterministically at multiple widths. Guarantees:
- *  - no rendered line exceeds `width`
- *  - long paths use middle-ellipsis
- *  - at most `maxBlockers` blockers shown; the rest point at the report artifact
- *  - color is applied only to status tokens, and only when enabled
- *  - readable with color stripped (screen-proof strips ANSI)
- */
 export function composeLaneFrame(view, opts = {}) {
     const width = Math.max(40, Number(opts.width || ZELLIJ_LANE_DEFAULT_WIDTH));
     const maxBlockers = Math.max(1, Number(opts.maxBlockers || ZELLIJ_LANE_MAX_BLOCKERS));
@@ -136,7 +113,6 @@ export function composeLaneFrame(view, opts = {}) {
     section('Reports');
     lines.push(middleEllipsis(`  proof: ${view.reports}`, width));
     section('Keys');
-    // Footer: real commands only. Wrap onto multiple lines if needed for width.
     let current = 'Keys:';
     for (const key of ZELLIJ_LANE_FOOTER_KEYS) {
         const candidate = current === 'Keys:' ? `${current} ${key}` : `${current} · ${key}`;
@@ -166,14 +142,6 @@ export async function renderZellijLaneFrame(opts) {
     const laneJson = await readJson(path.join(laneDir, 'lane.json'), null);
     const laneMd = await readText(path.join(laneDir, 'lane.md'), '');
     const commandBus = await processZellijLaneCommandBus(root, slot);
-    // The persistent MAD/Naruto lane watches its OWN mission ledger, but the
-    // the internal worker runtime writes scheduler state to
-    // a separate mission ledger. When this lane's own ledger has no live scheduler
-    // state, mirror the most-recent active agent mission so the lane reflects real
-    // parallel work instead of a permanent "Workers idle". Artifacts/heartbeat still
-    // write to the requested `root` so launch/heartbeat gates are unaffected; only the
-    // displayed lane state is sourced from `dataRoot`. Disable with
-    // SKS_LANE_FOLLOW_ACTIVE_MISSION=0.
     const dataRoot = await resolveActiveLedgerRoot(root);
     const laneState = await buildLaneState(dataRoot, slot, laneJson);
     const baseLaneNote = laneMd
@@ -353,14 +321,12 @@ async function buildLaneState(root, slot, laneJson) {
         firstPatchFile(apply),
         firstPatchFile(verify)
     ]) || 'none';
-    // Mode: Work / MAD-SKS / Naruto. Prefer explicit lane/scheduler hints.
     const mode = firstString([
         laneJson?.mode,
         scheduler?.mode,
         scheduler?.naruto_mode ? 'Naruto' : null,
         runtime?.mode
     ]) || 'Work';
-    // Fast service tier.
     const projectRoot = inferProjectRootFromLedgerRoot(root);
     const policy = resolveFastModePolicy({ root: projectRoot });
     const serviceTier = firstString([
@@ -380,7 +346,6 @@ async function buildLaneState(root, slot, laneJson) {
     const fast = serviceTier === 'fast' || fastMode === true
         ? `on · service_tier=${serviceTier || 'fast'}`
         : `off · service_tier=${serviceTier || 'standard'}`;
-    // Workers: live active/target plus the bounded worker total.
     const workerTotal = numberOf([scheduler?.workers, scheduler?.worker_count, runtime?.workers]);
     const activeWorkers = numberOf([scheduler?.active_worker_count, scheduler?.active_slot_count]);
     const workers = [
@@ -389,7 +354,6 @@ async function buildLaneState(root, slot, laneJson) {
         workerTotal ? `workers ${pad3(activeWorkers || 0)}/${pad3(workerTotal)}` : null,
         scheduler ? `pending ${scheduler.pending_count ?? 'n/a'}` : null
     ].filter(Boolean).join(' · ') || 'idle';
-    // Codex child sessions.
     const sessions = arrayFrom(runtime, ['sessions', 'workers', 'items']);
     const codexChild = worker
         ? `live ${worker.status || 'observed'} · result ${worker.result_status || 'pending'}`
@@ -628,11 +592,6 @@ function firstDefined(values) {
     }
     return undefined;
 }
-// Follow the freshest ledger that has actual native worker session data. A lane's
-// own mission can have a scheduler placeholder while the native/Naruto worker
-// runtime writes logs into a sibling agent ledger; showing the placeholder makes
-// the right panes look disconnected. Pure read; never mutates. Returns the
-// original root when nothing better is found or when disabled.
 async function resolveActiveLedgerRoot(ledgerRoot) {
     if (process.env.SKS_LANE_FOLLOW_ACTIVE_MISSION === '0')
         return ledgerRoot;

package/dist/core/zellij/zellij-lane-runtime.js

@@ -172,7 +172,6 @@ export function extractZellijPaneIdFromOutput(text) {
             return String(paneId).trim();
     }
     catch {
-        // Fall through to line-based parsing.
     }
     const lines = raw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
     for (const line of lines.slice().reverse()) {