sneakoscope 1.21.0 → 1.21.2

package/README.md

@@ -16,7 +16,7 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## Current Release
 
-SKS **1.21.0** carries forward the `sks --mad` Zellij auto-attach fix and aligns the release metadata gates with explicit version bumps. Previous releases only *created* a detached background session and printed an `Attach with: ...` hint, so nothing opened in the operator's terminal. SKS now performs the follow-up foreground attach automatically when launched in an interactive TTY (using the same `ZELLIJ_SOCKET_DIR` namespace as the background session), and falls back to printing the manual attach command if attach fails. Auto-attach is skipped for `--json`, non-TTY/piped launches, when already inside a Zellij session, or with `--no-attach` / `SKS_NO_ZELLIJ_ATTACH=1`; `--attach` forces it.
+SKS **1.21.2** fixes the `sks --mad` Zellij launch regression from 1.21.1: Zellij rejects `--copy-command` when it is paired with the OSC52-only `--copy-clipboard` flag, so SKS now passes only `--copy-command pbcopy` and `--copy-on-select true` on the launch CLI while keeping the generated clipboard config for attach-time behavior. It carries forward the 1.21.1 launch-speed and Codex legacy-profile fixes.
 
 SKS **1.20.4** is a targeted `sks --mad` / codex-lb Zellij usability patch: when a background MAD Zellij session launches successfully, SKS now prints the exact `Attach with: ZELLIJ_SOCKET_DIR=... zellij attach ...` command so operators can enter the fresh session without manually reconstructing the socket namespace.
 

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "1.21.0"
+version = "1.21.2"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "1.21.0"
+version = "1.21.2"
 edition = "2021"
 
 [dependencies]

package/crates/sks-core/src/main.rs

@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek, SeekFrom};
 fn main() {
     let mut args = std::env::args().skip(1);
     match args.next().as_deref() {
-        Some("--version") => println!("sks-rs 1.21.0"),
+        Some("--version") => println!("sks-rs 1.21.2"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/.sks-build-stamp.json

@@ -1,8 +1,8 @@
 {
   "schema": "sks.dist-build-stamp.v1",
   "package_name": "sneakoscope",
-  "package_version": "1.21.0",
-  "source_digest": "666db83626c95b8a8eae20389e647a2db96c4e22802cdf18ce0f7c142c9dbcaa",
-  "source_file_count": 1750,
-  "built_at_source_time": 1780297266324
+  "package_version": "1.21.2",
+  "source_digest": "c2de07d5136a6b0feccf10d8b647ffc2fcbc322e738bafd6cea43efdd3da1225",
+  "source_file_count": 1752,
+  "built_at_source_time": 1780308857966
 }

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '1.21.0';
+const FAST_PACKAGE_VERSION = '1.21.2';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

package/dist/build-manifest.json

@@ -1,16 +1,16 @@
 {
   "schema": "sks.dist-build.v2",
-  "version": "1.21.0",
-  "package_version": "1.21.0",
+  "version": "1.21.2",
+  "package_version": "1.21.2",
   "typescript": true,
   "mjs_runtime_files": 0,
-  "compiled_file_count": 1020,
-  "compiled_js_count": 510,
-  "compiled_dts_count": 510,
-  "source_digest": "666db83626c95b8a8eae20389e647a2db96c4e22802cdf18ce0f7c142c9dbcaa",
-  "source_file_count": 1750,
-  "source_files_hash": "de93b15a72352d00481b958333ed964bf083563809e3beddfe4e64046720df75",
-  "source_list_hash": "de93b15a72352d00481b958333ed964bf083563809e3beddfe4e64046720df75",
+  "compiled_file_count": 1022,
+  "compiled_js_count": 511,
+  "compiled_dts_count": 511,
+  "source_digest": "c2de07d5136a6b0feccf10d8b647ffc2fcbc322e738bafd6cea43efdd3da1225",
+  "source_file_count": 1752,
+  "source_files_hash": "6b8e7de7bcab2c6ddd83d31e15d7219e9d3f595813a1ec8173936208d3c877ef",
+  "source_list_hash": "6b8e7de7bcab2c6ddd83d31e15d7219e9d3f595813a1ec8173936208d3c877ef",
   "src_mjs_runtime_files": 0,
   "dist_stamp_schema": "sks.dist-build-stamp.v1",
   "files": [
@@ -1021,6 +1021,8 @@
     "core/work-order-ledger.js",
     "core/zellij/zellij-capability.d.ts",
     "core/zellij/zellij-capability.js",
+    "core/zellij/zellij-clipboard-config.d.ts",
+    "core/zellij/zellij-clipboard-config.js",
     "core/zellij/zellij-command.d.ts",
     "core/zellij/zellij-command.js",
     "core/zellij/zellij-lane-renderer.d.ts",

package/dist/cli/install-helpers.js

@@ -1525,21 +1525,18 @@ function normalizeCodexFastModeUiConfigOnce(text = '') {
     next = upsertTomlTableKeyIfAbsent(next, 'user.fast_mode', 'visible = true');
     next = upsertTomlTableKeyIfAbsent(next, 'user.fast_mode', 'enabled = true');
     next = upsertTomlTableKeyIfAbsent(next, 'user.fast_mode', 'default_profile = "sks-fast-high"');
+    // Keep ONLY the sks-fast-high config-profile table: the Codex App fast-mode
+    // (`[user.fast_mode] default_profile = "sks-fast-high"`) and the
+    // codex-app:ui-preservation gate still expect it. The other SKS config profiles are
+    // no longer written as `[profiles.sks-*]` tables here (Codex 0.134+ deprecates them);
+    // they are managed as per-file `<name>.config.toml` overlays by
+    // migrateSksProfilesToPerFile (src/core/auto-review.ts), which also writes the
+    // sks-fast-high overlay for CLI `--profile` use.
     next = upsertTomlTableKey(next, 'profiles.sks-fast-high', 'model = "gpt-5.5"');
     next = upsertTomlTableKey(next, 'profiles.sks-fast-high', 'service_tier = "fast"');
     next = upsertTomlTableKey(next, 'profiles.sks-fast-high', 'approval_policy = "on-request"');
     next = upsertTomlTableKey(next, 'profiles.sks-fast-high', 'sandbox_mode = "workspace-write"');
     next = upsertTomlTableKey(next, 'profiles.sks-fast-high', 'model_reasoning_effort = "high"');
-    next = upsertTomlTableKey(next, 'profiles.sks-research-xhigh', 'model = "gpt-5.5"');
-    next = upsertTomlTableKey(next, 'profiles.sks-research-xhigh', 'service_tier = "fast"');
-    next = upsertTomlTableKey(next, 'profiles.sks-research-xhigh', 'approval_policy = "on-request"');
-    next = upsertTomlTableKey(next, 'profiles.sks-research-xhigh', 'sandbox_mode = "workspace-write"');
-    next = upsertTomlTableKey(next, 'profiles.sks-research-xhigh', 'model_reasoning_effort = "xhigh"');
-    next = upsertTomlTableKey(next, 'profiles.sks-research', 'model = "gpt-5.5"');
-    next = upsertTomlTableKey(next, 'profiles.sks-research', 'service_tier = "fast"');
-    next = upsertTomlTableKey(next, 'profiles.sks-research', 'approval_policy = "never"');
-    next = upsertTomlTableKey(next, 'profiles.sks-research', 'sandbox_mode = "workspace-write"');
-    next = upsertTomlTableKey(next, 'profiles.sks-research', 'model_reasoning_effort = "xhigh"');
     // Plugin auto-enable is OPT-IN only. Force-writing `[plugins."name@marketplace"] enabled =
     // true` for marketplace plugins the App may not have installed (different build/channel)
     // makes the App reference plugins it cannot load -> broken/blocked plugin UI. It also

package/dist/commands/mad-sks.d.ts

@@ -27,6 +27,8 @@ export declare function run(_command: any, args?: any): Promise<void | {
     attach_requested: boolean;
     zellij_socket_dir: string | null;
     zellij_socket_dir_source: import("../core/zellij/zellij-command.js").ZellijSocketDirSource;
+    clipboard_config_path: string;
+    clipboard_copy_command: string;
     pane_proof_path: string;
     pane_proof: {
         schema: string;
@@ -119,6 +121,7 @@ export declare function run(_command: any, args?: any): Promise<void | {
             };
             moved_keys: string[];
             moved_tables: string[];
+            removed_legacy_profiles: string[];
             deprecated_approval_policy_fixed: boolean;
             actions: string[];
             parse_smoke: {

package/dist/core/auto-review.d.ts

@@ -74,6 +74,16 @@ export declare function enableAutoReview(opts?: any): Promise<{
         dynamic_effort: "parent assigns high effort to safety/integrator lanes and medium or higher to verification lanes when proof risk is present";
     }>;
 }>;
+export declare const SKS_CONFIG_PROFILES: Array<{
+    name: string;
+    stripTable: boolean;
+    block: string;
+}>;
+export declare function migrateSksProfilesToPerFile(opts?: any): Promise<{
+    config_path: any;
+    profiles_written: string[];
+    tables_stripped: string[];
+}>;
 export declare function enableMadHighProfile(opts?: any): Promise<{
     config_path: any;
     profile_config_path: string;

package/dist/core/auto-review.js

@@ -92,8 +92,63 @@ export async function enableAutoReview(opts = {}) {
         launch_args: ['--profile', autoReviewProfileName({ high })]
     };
 }
+// Canonical registry of every SKS config profile. Codex 0.134+ deprecated the
+// `[profiles.*]` tables / top-level `profile=` selector (warns at startup) in favor of
+// per-file `$CODEX_HOME/<name>.config.toml` overlays loaded by `--profile <name>`.
+// `stripTable: true` => remove the legacy `[profiles.<name>]` table from the home
+// config during migration. sks-fast-high keeps its table because the Codex App
+// fast-mode (`[user.fast_mode] default_profile = "sks-fast-high"`) and the
+// codex-app:ui-preservation gate still expect it; its per-file overlay is also written
+// so CLI `--profile sks-fast-high` works too.
+export const SKS_CONFIG_PROFILES = [
+    { name: 'sks-task-low', stripTable: true, block: sksProfileFileBlock({ effort: 'low' }) },
+    { name: 'sks-task-medium', stripTable: true, block: sksProfileFileBlock({ effort: 'medium' }) },
+    { name: 'sks-logic-high', stripTable: true, block: sksProfileFileBlock({ effort: 'high' }) },
+    { name: 'sks-fast-high', stripTable: false, block: sksProfileFileBlock({ effort: 'high', serviceTier: 'fast' }) },
+    { name: 'sks-research-xhigh', stripTable: true, block: sksProfileFileBlock({ effort: 'xhigh' }) },
+    { name: 'sks-research', stripTable: true, block: sksProfileFileBlock({ effort: 'xhigh', approvalPolicy: 'never' }) },
+    { name: 'sks-team', stripTable: true, block: sksProfileFileBlock({ effort: 'medium' }) },
+    { name: MAD_HIGH_PROFILE, stripTable: true, block: sksProfileFileBlock({ effort: 'high', approvalPolicy: 'never', sandboxMode: 'danger-full-access', reviewer: AUTO_REVIEW_REVIEWER }) },
+    { name: 'sks-default', stripTable: true, block: sksProfileFileBlock({ effort: 'high' }) }
+];
+function sksProfileFileBlock(opts = {}) {
+    return [
+        'model = "gpt-5.5"',
+        `service_tier = "${opts.serviceTier || 'fast'}"`,
+        `approval_policy = "${opts.approvalPolicy || 'on-request'}"`,
+        ...(opts.reviewer ? [`approvals_reviewer = "${opts.reviewer}"`] : []),
+        `sandbox_mode = "${opts.sandboxMode || 'workspace-write'}"`,
+        `model_reasoning_effort = "${opts.effort || 'medium'}"`
+    ].join('\n');
+}
+// Migrate every SKS config profile to a per-file `<name>.config.toml` overlay in
+// CODEX_HOME and strip the deprecated legacy `[profiles.sks-*]` tables / `profile=`
+// selectors from the home config. Idempotent (second run is a no-op). This is the
+// step that clears the Codex deprecation warning on `sks --mad`.
+export async function migrateSksProfilesToPerFile(opts = {}) {
+    const configPath = opts.configPath || codexConfigPath(opts.env || process.env);
+    await ensureDir(path.dirname(configPath));
+    const current = await readText(configPath, '');
+    let next = String(current || '');
+    for (const profile of SKS_CONFIG_PROFILES) {
+        if (profile.stripTable)
+            next = removeLegacyProfileConfig(next, profile.name);
+    }
+    if (next && !next.endsWith('\n'))
+        next += '\n';
+    if (next !== String(current || ''))
+        await writeTextAtomic(configPath, next);
+    for (const profile of SKS_CONFIG_PROFILES)
+        await writeProfileConfig(configPath, profile.name, profile.block);
+    return {
+        config_path: configPath,
+        profiles_written: SKS_CONFIG_PROFILES.map((profile) => profile.name),
+        tables_stripped: SKS_CONFIG_PROFILES.filter((profile) => profile.stripTable).map((profile) => profile.name)
+    };
+}
 export async function enableMadHighProfile(opts = {}) {
     const configPath = opts.configPath || codexConfigPath(opts.env || process.env);
+    const env = opts.env || process.env;
     await ensureDir(path.dirname(configPath));
     const current = await readText(configPath, '');
     let next = removeLegacyProfileConfig(current, MAD_HIGH_PROFILE);
@@ -101,6 +156,9 @@ export async function enableMadHighProfile(opts = {}) {
     if (!next.endsWith('\n'))
         next += '\n';
     await writeTextAtomic(configPath, next);
+    // Convert all SKS profiles to per-file overlays and strip the deprecated tables /
+    // selectors so Codex stops warning about the legacy config profile on launch.
+    await migrateSksProfilesToPerFile({ configPath, env });
     await writeProfileConfig(configPath, MAD_HIGH_PROFILE, profileConfigBlock({
         effort: 'high',
         approvalPolicy: 'never',

package/dist/core/codex/codex-config-eperm-repair.d.ts

@@ -40,6 +40,7 @@ export declare function repairCodexConfigEperm(rootInput?: string, opts?: any):
         };
         moved_keys: string[];
         moved_tables: string[];
+        removed_legacy_profiles: string[];
         deprecated_approval_policy_fixed: boolean;
         actions: string[];
         parse_smoke: {

package/dist/core/codex/codex-project-config-policy.d.ts

@@ -32,6 +32,7 @@ export declare function splitCodexProjectConfigPolicy(rootInput?: string, opts?:
     };
     moved_keys: string[];
     moved_tables: string[];
+    removed_legacy_profiles: string[];
     deprecated_approval_policy_fixed: boolean;
     actions: string[];
     parse_smoke: {

package/dist/core/codex/codex-project-config-policy.js

@@ -4,8 +4,6 @@ import path from 'node:path';
 import { ensureDir, nowIso, readText, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
 export const CODEX_PROJECT_CONFIG_POLICY_SCHEMA = 'sks.codex-project-config-policy.v1';
 const MACHINE_LOCAL_TOP_LEVEL_KEYS = new Set([
-    'profile',
-    'profiles',
     'model_provider',
     'model_providers',
     'openai_base_url',
@@ -20,13 +18,23 @@ const MACHINE_LOCAL_TOP_LEVEL_KEYS = new Set([
     'telemetry'
 ]);
 const MACHINE_LOCAL_TABLE_PREFIXES = [
-    'profiles',
     'model_providers',
     'notify',
     'otel',
     'telemetry',
     'experimental_telemetry'
 ];
+// Codex 0.134+ removed the legacy config-profile consumers: `--profile NAME` now
+// layers `$CODEX_HOME/<name>.config.toml` over the base config and the top-level
+// `profile = "..."` selector / `[profiles.*]` tables are deprecated and warned about
+// at startup. So these are NO LONGER machine-local-and-moved-to-home — they are
+// DROPPED from the project config entirely. The per-file profiles are owned by
+// migrateSksProfilesToPerFile (src/core/auto-review.ts), which runs on `sks --mad`.
+const DEPRECATED_LEGACY_PROFILE_TOP_LEVEL_KEYS = new Set(['profile', 'profiles']);
+const DEPRECATED_LEGACY_PROFILE_TABLE_PREFIXES = ['profiles'];
+function isDeprecatedLegacyProfileTable(table) {
+    return DEPRECATED_LEGACY_PROFILE_TABLE_PREFIXES.some((prefix) => table === prefix || table.startsWith(`${prefix}.`));
+}
 export async function splitCodexProjectConfigPolicy(rootInput = process.cwd(), opts = {}) {
     const root = path.resolve(rootInput || process.cwd());
     const configPath = path.resolve(opts.configPath || path.join(root, '.codex', 'config.toml'));
@@ -124,6 +132,7 @@ export async function splitCodexProjectConfigPolicy(rootInput = process.cwd(), o
         },
         moved_keys: split.moved_keys,
         moved_tables: split.moved_tables,
+        removed_legacy_profiles: split.removed_legacy_profiles,
         deprecated_approval_policy_fixed: split.deprecated_approval_policy_fixed,
         actions,
         parse_smoke: parseSmoke,
@@ -250,10 +259,17 @@ function splitProjectToml(text) {
     const machineBlocks = [];
     const movedKeys = [];
     const movedTables = [];
+    const removedLegacyProfiles = [];
     const blockers = [];
     let profileName = null;
     let deprecatedFixed = false;
     for (const block of blocks) {
+        // Deprecated legacy config profiles are DROPPED, not moved to the home config
+        // (Codex 0.134+ warns about `[profiles.*]` tables and the `profile=` selector).
+        if (block.table && isDeprecatedLegacyProfileTable(block.table)) {
+            removedLegacyProfiles.push(block.table);
+            continue;
+        }
         if (block.table && isMachineLocalTable(block.table)) {
             if (block.array) {
                 kept.push(block.text);
@@ -270,11 +286,15 @@ function splitProjectToml(text) {
             const moveLines = [];
             for (const line of block.text.split('\n')) {
                 const key = topLevelKey(line);
+                if (key && DEPRECATED_LEGACY_PROFILE_TOP_LEVEL_KEYS.has(key)) {
+                    if (key === 'profile')
+                        profileName = tomlStringValue(line);
+                    removedLegacyProfiles.push(`top_level:${key}`);
+                    continue;
+                }
                 if (key && MACHINE_LOCAL_TOP_LEVEL_KEYS.has(key)) {
                     moveLines.push(line);
                     movedKeys.push(key);
-                    if (key === 'profile')
-                        profileName = tomlStringValue(line);
                     continue;
                 }
                 const fixed = fixDeprecatedApprovalPolicy(line);
@@ -302,6 +322,7 @@ function splitProjectToml(text) {
         machine_blocks: machineBlocks,
         moved_keys: [...new Set(movedKeys)],
         moved_tables: [...new Set(movedTables)],
+        removed_legacy_profiles: [...new Set(removedLegacyProfiles)],
         kept_keys: [],
         profile_name: profileName,
         deprecated_approval_policy_fixed: deprecatedFixed,

package/dist/core/commands/mad-sks-command.d.ts

@@ -27,6 +27,8 @@ export declare function madHighCommand(args?: any, deps?: any): Promise<void | {
     attach_requested: boolean;
     zellij_socket_dir: string | null;
     zellij_socket_dir_source: import("../zellij/zellij-command.js").ZellijSocketDirSource;
+    clipboard_config_path: string;
+    clipboard_copy_command: string;
     pane_proof_path: string;
     pane_proof: {
         schema: string;
@@ -119,6 +121,7 @@ export declare function madHighCommand(args?: any, deps?: any): Promise<void | {
             };
             moved_keys: string[];
             moved_tables: string[];
+            removed_legacy_profiles: string[];
             deprecated_approval_policy_fixed: boolean;
             actions: string[];
             parse_smoke: {

package/dist/core/commands/mad-sks-command.js

@@ -57,7 +57,12 @@ export async function madHighCommand(args = [], deps = {}) {
     const launchRoot = process.cwd();
     if (!(await exists(path.join(launchRoot, '.sneakoscope'))))
         await initProject(launchRoot, {});
-    const launchPreflight = await runCodexLaunchPreflight(launchRoot, { fix: true, profile: profile.profile_name, sandbox: 'danger-full-access', serviceTier: 'fast' });
+    // launchFast skips the redundant live-`codex exec` config probe (up to ~20s, run
+    // up to 3x via repair re-inspections): the real codex profile is exercised moments
+    // later when the Zellij session opens. All filesystem/permission/EPERM/symlink/ACL
+    // readability + repair checks still run. SKS_LAUNCH_FULL_CODEX_PROBE=1 restores the
+    // old behavior.
+    const launchPreflight = await runCodexLaunchPreflight(launchRoot, { fix: true, launchFast: process.env.SKS_LAUNCH_FULL_CODEX_PROBE !== '1', profile: profile.profile_name, sandbox: 'danger-full-access', serviceTier: 'fast' });
     if (!launchPreflight.ok) {
         console.error('SKS MAD launch blocked by config preflight.');
         for (const blocker of launchPreflight.blockers || [])
@@ -88,7 +93,7 @@ export async function madHighCommand(args = [], deps = {}) {
     // instead of leaving them to copy/paste the attach command by hand.
     if (shouldAutoAttachZellij(args)) {
         console.log(`Opening Zellij session: ${launch.session_name} (detach with Ctrl+q, re-attach later with: ${launch.attach_command_with_env})`);
-        const attached = attachZellijSessionInteractive(launch.session_name, { cwd: process.cwd() });
+        const attached = attachZellijSessionInteractive(launch.session_name, { cwd: process.cwd(), configPath: launch.clipboard_config_path });
         if (!attached.ok) {
             console.log(`Could not open the Zellij session automatically${attached.error ? ` (${attached.error})` : ''}.`);
             if (launch.attach_command_with_env)
@@ -148,7 +153,12 @@ async function activateMadZellijPermissionState(cwd = process.cwd(), args = [])
     const dbWriteAllowed = has('db_write');
     const { id, dir } = await createMission(root, { mode: 'mad-sks', prompt: 'sks --mad Zellij scoped high-power maintenance session' });
     const protectedCore = resolveProtectedCore({ packageRoot: packageRoot(), targetRoot: cwd });
-    const protectedCoreBefore = await snapshotProtectedCore(packageRoot(), 'mad-live-before');
+    // The interactive launch 'before' snapshot is only persisted (env + policy json)
+    // and is never compared against an 'after' snapshot during the session, so the
+    // strong full-content hash is wasted here. Use the cheap metadata digest (no file
+    // reads) on the launch hot path. run/apply and the release gates still take their
+    // own strong content snapshots where the digest is actually compared.
+    const protectedCoreBefore = await snapshotProtectedCore(packageRoot(), 'mad-live-before', { mode: 'metadata' });
     const protectedCorePolicyPath = path.join(dir, 'mad-sks-protected-core-policy.json');
     const protectedCoreBeforePath = path.join(dir, 'mad-sks-live-protected-core-before.json');
     await writeJsonAtomic(protectedCorePolicyPath, {

package/dist/core/fsx.d.ts

@@ -1,4 +1,4 @@
-export declare const PACKAGE_VERSION = "1.21.0";
+export declare const PACKAGE_VERSION = "1.21.2";
 export declare const DEFAULT_PROCESS_TAIL_BYTES: number;
 export declare const DEFAULT_PROCESS_TIMEOUT_MS: number;
 export interface RunProcessOptions {

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '1.21.0';
+export const PACKAGE_VERSION = '1.21.2';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/init.js

@@ -803,19 +803,16 @@ export async function initProject(root, opts = {}) {
             { table: 'agents.implementation_worker', text: agentConfigBlock('implementation_worker', 'SKS bounded implementation worker.', './agents/implementation-worker.toml', ['Builder', 'Mason']) },
             { table: 'agents.db_safety_reviewer', text: agentConfigBlock('db_safety_reviewer', 'Read-only DB safety reviewer.', './agents/db-safety-reviewer.toml', ['Sentinel', 'Ledger']) },
             { table: 'agents.qa_reviewer', text: agentConfigBlock('qa_reviewer', 'Read-only QA reviewer.', './agents/qa-reviewer.toml', ['Verifier', 'Reviewer']) },
-            { table: 'profiles.sks-task-low', text: profileConfigBlock('sks-task-low', 'low') },
-            { table: 'profiles.sks-task-medium', text: profileConfigBlock('sks-task-medium', 'medium') },
-            { table: 'profiles.sks-logic-high', text: profileConfigBlock('sks-logic-high', 'high') },
-            { table: 'profiles.sks-fast-high', text: profileConfigBlock('sks-fast-high', 'high', { serviceTier: 'fast' }) },
-            { table: 'profiles.sks-research-xhigh', text: profileConfigBlock('sks-research-xhigh', 'xhigh') },
-            { table: 'profiles.sks-research', text: profileConfigBlock('sks-research', 'xhigh', { approval: 'never' }) },
-            { table: 'profiles.sks-team', text: profileConfigBlock('sks-team', 'medium') },
-            { table: 'profiles.sks-mad-high', text: profileConfigBlock('sks-mad-high', 'high', { approval: 'never', sandbox: 'danger-full-access', approvalsReviewer: 'auto_review' }) },
+            // NOTE: SKS config profiles are NO LONGER emitted as `[profiles.sks-*]` tables.
+            // Codex 0.134+ deprecated config-profile tables / the `profile=` selector (warns at
+            // startup) in favor of per-file `$CODEX_HOME/<name>.config.toml` overlays loaded by
+            // `--profile <name>`. Those per-file profiles are owned by migrateSksProfilesToPerFile
+            // (src/core/auto-review.ts), invoked on `sks --mad`. Emitting the tables here only got
+            // them relocated into the home config by the splitter, re-triggering the warning.
             {
                 table: 'auto_review',
                 text: '[auto_review]\npolicy = "In MAD launches, allow live-server work, normal DB writes, Supabase MCP DB writes, direct execute SQL, schema cleanup, and migration application for the active invocation. Deny only catastrophic database wipes, all-row value deletion/update, dangerous project or branch management, credential exfiltration, persistent security weakening, broad unrelated file deletion, and unrequested fallback implementation code."'
-            },
-            { table: 'profiles.sks-default', text: profileConfigBlock('sks-default', 'high') }
+            }
         ];
     }
     function agentConfigBlock(table, description, configFile, nicknames = []) {
@@ -826,17 +823,6 @@ export async function initProject(root, opts = {}) {
             `nickname_candidates = [${nicknames.map((name) => `"${name}"`).join(', ')}]`
         ].join('\n');
     }
-    function profileConfigBlock(profile, effort, opts = {}) {
-        return [
-            `[profiles.${profile}]`,
-            'model = "gpt-5.5"',
-            `service_tier = "${opts.serviceTier || 'fast'}"`,
-            `approval_policy = "${opts.approval || 'on-request'}"`,
-            ...(opts.approvalsReviewer ? [`approvals_reviewer = "${opts.approvalsReviewer}"`] : []),
-            `sandbox_mode = "${opts.sandbox || 'workspace-write'}"`,
-            `model_reasoning_effort = "${effort}"`
-        ].join('\n');
-    }
     function upsertTomlTableKey(text, table, line) {
         const key = (String(line).split('=')[0] || '').trim();
         let lines = String(text || '').split('\n');

package/dist/core/mad-sks/immutable-harness-guard.d.ts

@@ -83,9 +83,13 @@ export declare function evaluateMadSksWrite({ packageRoot: packageRootInput, tar
     };
     wrongness_kind: string | null;
 }>;
-export declare function snapshotProtectedCore(root?: string, label?: string): Promise<{
+export interface SnapshotProtectedCoreOptions {
+    mode?: 'content' | 'metadata';
+}
+export declare function snapshotProtectedCore(root?: string, label?: string, opts?: SnapshotProtectedCoreOptions): Promise<{
     schema: string;
     label: string;
+    digest_mode: string;
     generated_at: string;
     package_root: string;
     engine_source_exception: boolean;
@@ -116,6 +120,7 @@ export declare function buildProtectedCoreSnapshot({ packageRoot: packageRootInp
 }): Promise<{
     schema: string;
     label: string;
+    digest_mode: string;
     generated_at: string;
     package_root: string;
     engine_source_exception: boolean;

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

@@ -122,16 +122,18 @@ export async function evaluateMadSksWrite({ packageRoot: packageRootInput = pack
         wrongness_kind: decision.wrongness_kind
     };
 }
-export async function snapshotProtectedCore(root = packageRoot(), label = 'snapshot') {
+export async function snapshotProtectedCore(root = packageRoot(), label = 'snapshot', opts = {}) {
+    const mode = opts.mode === 'metadata' ? 'metadata' : 'content';
     const resolution = resolveProtectedCore(root);
     const entries = [];
     for (const entry of resolution.protected_paths) {
-        entries.push(await hashProtectedEntry(entry));
+        entries.push(mode === 'metadata' ? await metadataHashProtectedEntry(entry) : await hashProtectedEntry(entry));
     }
     const digest = sha256(entries.map((entry) => `${entry.id}:${entry.hash || 'missing'}:${entry.file_count}:${entry.bytes}`).join('\n'));
     return {
         schema: MAD_SKS_PROTECTED_CORE_SNAPSHOT_SCHEMA,
         label,
+        digest_mode: mode,
         generated_at: nowIso(),
         package_root: resolution.package_root,
         engine_source_exception: resolution.engine_source_exception,
@@ -186,6 +188,35 @@ 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 };
+    }
+    const stat = await fsp.lstat(entry.absolute_path);
+    if (stat.isFile()) {
+        return { id: entry.id, path: entry.path, relative_path: entry.path, present: true, hash: sha256(`${stat.mtimeMs}:${stat.size}:${stat.mode}`), file_count: 1, bytes: stat.size };
+    }
+    if (!stat.isDirectory()) {
+        return { id: entry.id, path: entry.path, relative_path: entry.path, present: true, hash: sha256(`${stat.mode}:${stat.size}`), file_count: 1, bytes: stat.size };
+    }
+    if (entry.match === 'exact') {
+        return { id: entry.id, path: entry.path, relative_path: entry.path, present: true, hash: sha256(`dir:${stat.mode}:${stat.uid}:${stat.gid}`), file_count: 1, bytes: 0 };
+    }
+    const files = await walk(entry.absolute_path);
+    let bytes = 0;
+    const parts = [];
+    for (const file of files.sort()) {
+        const st = await fsp.lstat(file);
+        bytes += st.size;
+        parts.push(`${path.relative(entry.absolute_path, file).split(path.sep).join('/')}:${st.mtimeMs}:${st.size}:${st.mode}`);
+    }
+    return { id: entry.id, path: entry.path, relative_path: entry.path, present: true, hash: sha256(parts.join('\n')), file_count: files.length, bytes };
+}
 async function walk(dir, out = []) {
     const entries = await fsp.readdir(dir, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {

package/dist/core/preflight/parallel-preflight-engine.d.ts

@@ -78,6 +78,7 @@ export declare function runCodexLaunchPreflight(rootInput?: string, opts?: any):
             };
             moved_keys: string[];
             moved_tables: string[];
+            removed_legacy_profiles: string[];
             deprecated_approval_policy_fixed: boolean;
             actions: string[];
             parse_smoke: {

package/dist/core/preflight/parallel-preflight-engine.js

@@ -29,12 +29,19 @@ export async function runParallelPreflight(checks) {
 export async function runCodexLaunchPreflight(rootInput = process.cwd(), opts = {}) {
     const root = path.resolve(rootInput || process.cwd());
     const reportPath = opts.reportPath || path.join(root, '.sneakoscope', 'reports', 'mad-launch-preflight.json');
+    // On the interactive launch path the real codex profile is exercised the moment the
+    // Zellij session opens, so spawning `codex exec` here (up to ~20s, and again inside
+    // the repair re-inspections) is redundant. launchFast skips ONLY the live-codex probe;
+    // all filesystem/permission/symlink/ACL/EPERM readability + repair checks still run, so
+    // the EPERM/tcc_possible/EACCES blockers still fire for unreadable configs
+    // (codex_cli_config_eperm is probe-only and intentionally not exercised on this path).
+    const probeCodex = opts.launchFast === true ? false : opts.actualCodex !== false;
     const readonly = await runParallelPreflight([
-        { id: 'codex_config_readability', run: () => inspectCodexConfigReadability(root, { ...opts, codexProbe: true, actualCodex: opts.actualCodex !== false, writeReport: false }) },
+        { id: 'codex_config_readability', run: () => inspectCodexConfigReadability(root, { ...opts, codexProbe: probeCodex, actualCodex: probeCodex, writeReport: false }) },
         { id: 'codex_project_config_policy', run: () => splitCodexProjectConfigPolicy(root, { ...opts, writeReport: false }) }
     ]);
     const repair = opts.fix === true || readonly.ok === false
-        ? await repairCodexConfigEperm(root, { ...opts, codexProbe: true, actualCodex: opts.actualCodex !== false, fix: opts.fix !== false, writeReport: false })
+        ? await repairCodexConfigEperm(root, { ...opts, codexProbe: probeCodex, actualCodex: probeCodex, fix: opts.fix !== false, writeReport: false })
         : null;
     const zellijCapability = opts.zellijCapability === false
         ? null

package/dist/core/version.d.ts

@@ -1,2 +1,2 @@
-export declare const PACKAGE_VERSION = "1.21.0";
+export declare const PACKAGE_VERSION = "1.21.2";
 //# sourceMappingURL=version.d.ts.map

package/dist/core/version.js

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

package/dist/core/zellij/zellij-clipboard-config.d.ts

@@ -0,0 +1,21 @@
+export declare const ZELLIJ_CLIPBOARD_CONFIG_SCHEMA = "sks.zellij-clipboard-config.v1";
+export interface ZellijClipboardConfig {
+    copy_command: string;
+    copy_clipboard: 'system' | 'primary';
+    copy_on_select: boolean;
+    /** Flags to append to the `zellij ... options` subcommand for the created session. */
+    optionFlags: string[];
+    /** Path to a dedicated config.kdl for the interactive attach (delivered via ZELLIJ_CONFIG_FILE). */
+    config_path: string;
+    generated_at: string;
+}
+/** Pick the platform-correct clipboard command. macOS is the primary target. */
+export declare function resolveCopyCommand(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): string;
+/** Render a minimal, valid Zellij config.kdl that enables clipboard copy. */
+export declare function buildZellijClipboardKdl(cfg: {
+    copy_command: string;
+    copy_clipboard: 'system' | 'primary';
+    copy_on_select: boolean;
+}): string;
+export declare function writeZellijClipboardConfig(root: string, missionId: string, platform?: NodeJS.Platform): Promise<ZellijClipboardConfig>;
+//# sourceMappingURL=zellij-clipboard-config.d.ts.map

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

@@ -0,0 +1,55 @@
+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 — so text selected inside a pane never
+// reaches the system clipboard. Setting copy_command="pbcopy" pipes selections
+// straight to the macOS clipboard, and copy_on_select=true makes a mouse drag
+// copy without entering copy mode. (Shift+drag still falls back to native
+// terminal selection regardless.)
+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';
+}
+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.',
+        `copy_command ${kdlString(cfg.copy_command)}`,
+        `copy_clipboard ${kdlString(cfg.copy_clipboard)}`,
+        `copy_on_select ${cfg.copy_on_select ? 'true' : 'false'}`,
+        ''
+    ].join('\n');
+}
+export async function writeZellijClipboardConfig(root, missionId, platform = process.platform) {
+    const copy_command = resolveCopyCommand(platform);
+    const copy_clipboard = 'system';
+    const copy_on_select = true;
+    const dir = path.join(root, '.sneakoscope', 'missions', missionId);
+    await ensureDir(dir);
+    const config_path = path.join(dir, 'zellij-clipboard.kdl');
+    await writeTextAtomic(config_path, buildZellijClipboardKdl({ copy_command, copy_clipboard, copy_on_select }));
+    return {
+        copy_command,
+        copy_clipboard,
+        copy_on_select,
+        // 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)],
+        config_path,
+        generated_at: nowIso()
+    };
+}
+//# sourceMappingURL=zellij-clipboard-config.js.map

package/dist/core/zellij/zellij-launcher.d.ts

@@ -44,6 +44,8 @@ export declare function launchZellijLayout(opts?: ZellijLaunchOptions): Promise<
     attach_requested: boolean;
     zellij_socket_dir: string | null;
     zellij_socket_dir_source: import("./zellij-command.js").ZellijSocketDirSource;
+    clipboard_config_path: string;
+    clipboard_copy_command: string;
     pane_proof_path: string;
     pane_proof: {
         schema: string;
@@ -105,6 +107,8 @@ export declare function launchMadZellijUi(args?: readonly unknown[], opts?: Zell
     attach_requested: boolean;
     zellij_socket_dir: string | null;
     zellij_socket_dir_source: import("./zellij-command.js").ZellijSocketDirSource;
+    clipboard_config_path: string;
+    clipboard_copy_command: string;
     pane_proof_path: string;
     pane_proof: {
         schema: string;
@@ -166,6 +170,8 @@ export declare function launchTeamZellijView(opts?: ZellijLaunchOptions): Promis
     attach_requested: boolean;
     zellij_socket_dir: string | null;
     zellij_socket_dir_source: import("./zellij-command.js").ZellijSocketDirSource;
+    clipboard_config_path: string;
+    clipboard_copy_command: string;
     pane_proof_path: string;
     pane_proof: {
         schema: string;
@@ -217,6 +223,7 @@ export interface ZellijAttachResult {
  */
 export declare function attachZellijSessionInteractive(sessionName: string, opts?: {
     cwd?: string;
+    configPath?: string;
 }): ZellijAttachResult;
 export declare function sanitizeZellijSessionName(value: unknown): string;
 //# sourceMappingURL=zellij-launcher.d.ts.map

package/dist/core/zellij/zellij-launcher.js

@@ -4,6 +4,7 @@ import { appendJsonl, nowIso, sha256, writeJsonAtomic } from '../fsx.js';
 import { checkZellijCapability } from './zellij-capability.js';
 import { formatZellijCommand, resolveZellijProcessEnvMeta, runZellij } from './zellij-command.js';
 import { writeZellijLayout } from './zellij-layout-builder.js';
+import { writeZellijClipboardConfig } from './zellij-clipboard-config.js';
 import { writeZellijPaneProof } from './zellij-pane-proof.js';
 export const ZELLIJ_SESSION_SCHEMA = 'sks.zellij-session.v1';
 export const ZELLIJ_SESSION_NAME_MAX = 64;
@@ -27,7 +28,13 @@ export async function launchZellijLayout(opts = {}) {
         layoutInput.codexBin = opts.codexBin;
     const layout = await writeZellijLayout(root, layoutInput);
     const capability = await checkZellijCapability({ root, require: opts.requireZellij === true });
-    const createCommand = ['attach', '--create-background', sessionName, 'options', '--default-layout', layout.layout_path];
+    // Configure the clipboard pipeline so selections inside the session reach the OS
+    // clipboard (Zellij's default OSC-52 copy is dropped by Terminal.app etc.). The
+    // copy option flags are appended AFTER `--default-layout <path>` so the launch
+    // command prefix ['zellij','attach','--create-background',session,'options','--default-layout',...]
+    // is preserved (required by the zellij launch-command-truth gate + E2E assertions).
+    const clipboard = await writeZellijClipboardConfig(root, missionId);
+    const createCommand = ['attach', '--create-background', sessionName, 'options', '--default-layout', layout.layout_path, ...clipboard.optionFlags];
     const attachCommand = ['attach', sessionName];
     const zellijEnv = resolveZellijProcessEnvMeta();
     const launch = opts.dryRun === true || capability.status !== 'ok'
@@ -86,6 +93,8 @@ export async function launchZellijLayout(opts = {}) {
         attach_requested: opts.attach === true,
         zellij_socket_dir: zellijEnv.zellij_socket_dir,
         zellij_socket_dir_source: zellijEnv.zellij_socket_dir_source,
+        clipboard_config_path: clipboard.config_path,
+        clipboard_copy_command: clipboard.copy_command,
         pane_proof_path: path.join(root, '.sneakoscope', 'missions', missionId, 'zellij-pane-proof.json'),
         pane_proof: paneProof,
         dry_run: opts.dryRun === true,
@@ -146,6 +155,13 @@ export function attachZellijSessionInteractive(sessionName, opts = {}) {
     const env = { ...process.env };
     if (meta.zellij_socket_dir && !env.ZELLIJ_SOCKET_DIR)
         env.ZELLIJ_SOCKET_DIR = meta.zellij_socket_dir;
+    // Steer the foreground attach at our generated clipboard config so the interactive
+    // session honors copy_command=pbcopy + copy_on_select. The `options` subcommand only
+    // configures the *created* background session, so the attach needs its own config
+    // delivery; ZELLIJ_CONFIG_FILE avoids reordering CLI args. Defer to a user-exported
+    // ZELLIJ_CONFIG_FILE if they already set one.
+    if (opts.configPath && !env.ZELLIJ_CONFIG_FILE)
+        env.ZELLIJ_CONFIG_FILE = opts.configPath;
     try {
         const result = spawnSync('zellij', ['attach', sessionName], {
             cwd: opts.cwd || process.cwd(),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "1.21.0",
+  "version": "1.21.2",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",