sneakoscope 1.20.2 → 1.20.3

package/README.md

@@ -16,7 +16,9 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## Current Release
 
-SKS **1.20.2** is a stabilization patch that closes the enforcement/integration/execution layers on top of the 1.20.1 infrastructure: a **Mutation Guard** routes genuinely-risky global/config/permission/package mutations through the Requested-Scope Contract + Mutation Ledger (`safety:mutation-callsite-coverage` fails any unguarded, unallowlisted risky call site); `release:check:dynamic:execute` turns the change-aware planner into a real **caching gate runner** (schema v2, real/heavy gates deferred to `release:real-check`, dynamic-only cannot authorize publish); the **Core Skill** deployed snapshot is now read by the route runtime and recorded in `agent-proof-evidence.json` (`selected_core_skill`), with promotions written to the mutation ledger; and `sks doctor` exposes an explicit **`zellij_readiness`** block (`zellij:doctor-readiness`). See `docs/dynamic-release-pipeline.md`.
+SKS **1.20.3** is a targeted patch for `sks --mad` / codex-lb sessions on macOS and project-local Fast mode control. SKS now supplies a short per-user `ZELLIJ_SOCKET_DIR` by default, caps generated session names safely, records `*_command_with_env` attach commands, and classifies `IPC socket path is too long` as `zellij_socket_path_too_long` instead of a generic launch failure. It also adds `sks fast-mode on|off|status|clear`, `$Fast-On`, `$Fast-Off`, and `$Fast-Mode`; saved project preferences are used only when no explicit `--fast`, `--no-fast`, or `--service-tier` flag is present.
+
+It carries forward the **1.20.2** stabilization layer: **Mutation Guard** routes genuinely-risky global/config/permission/package mutations through the Requested-Scope Contract + Mutation Ledger (`safety:mutation-callsite-coverage` fails any unguarded, unallowlisted risky call site); `release:check:dynamic:execute` is the real **caching gate runner** (schema v2, real/heavy gates deferred to `release:real-check`, dynamic-only cannot authorize publish); the **Core Skill** deployed snapshot is read by the route runtime and recorded in `agent-proof-evidence.json` (`selected_core_skill`), with promotions written to the mutation ledger; and `sks doctor` exposes an explicit **`zellij_readiness`** block (`zellij:doctor-readiness`). See `docs/dynamic-release-pipeline.md`.
 
 SKS **1.20.1** introduces the **SKS Core Skill Engine** — a SkillOpt-style self-evolving skill layer — while locking the harness into a deploy-ready stable build. Skills are the agent's *external, versioned state* (Core Skill Cards): an optimizer proposes **bounded** add/delete/replace edits to a single skill document under a **textual edit budget**, edits are accepted **only on strict held-out improvement**, rejected edits are buffered so they are never retried, and the **deployed snapshot is immutable**. Critically, the optimizer runs only in training/evaluation — the **deployment/inference path reads the deployed snapshot and never makes an extra model call**, and a skill patch can never mutate code/config/package/global files.
 
@@ -140,7 +142,7 @@ The cleanup contract is policy-backed in `.sneakoscope/policy.json`, but the def
 - Agent patch queue: [docs/agent-patch-queue.md](docs/agent-patch-queue.md)
 - Native CLI Session Swarm: [docs/native-cli-session-swarm.md](docs/native-cli-session-swarm.md)
 - No-subagent scaling: [docs/no-subagent-scaling.md](docs/no-subagent-scaling.md)
-- Fast mode default: [docs/fast-mode-default.md](docs/fast-mode-default.md)
+- Fast mode default and `$Fast-On`/`$Fast-Off` toggles: [docs/fast-mode-default.md](docs/fast-mode-default.md)
 - Migration 1.18.7 to 1.18.8: [docs/migration-1.18.7-to-1.18.8.md](docs/migration-1.18.7-to-1.18.8.md)
 - Codex official Goal mode: [docs/codex-official-goal-mode.md](docs/codex-official-goal-mode.md)
 - Release parallel full coverage: [docs/release-parallel-full-coverage.md](docs/release-parallel-full-coverage.md)
@@ -731,7 +733,7 @@ npm run release:check
 npm run publish:dry
 ```
 
-`release:check` runs the 1.19.0 Zellij dependency-repair closure DAG, writes a source digest stamp under `.sneakoscope/reports/`, then refreshes release readiness so publish commands can verify the same stamp. The DAG preserves the 1.18 baseline gates and adds patch swarm runtime truth, transaction journaling, serial conflict rebase, strict strategy-to-patch proof, rollback command proof, Native CLI Session Swarm 5/10/20-process proof, Real Worker Backend Router proof, Codex child overlap proof, model-authored patch-envelope separation, Zellij layout/pane/screen proof, no-subagent-scaling proof, Fast mode default/worker/Codex/MAD propagation proof, Appshots attachment provenance, MCP runtime overlap evidence, Codex 0.134/0.135 runner truth, task graph expansion, schema-bound follow-up work, actual Agent/Team/Research/QA route blackboxes, scheduler proof hardening, Source Intelligence propagation, and Goal mode propagation checks. Broader live gates remain explicit scripts such as `release:real-check`; real Codex patch smoke, real Codex parallel worker proof, and real Zellij proof are optional unless their `SKS_REQUIRE_REAL_*` or `SKS_REQUIRE_ZELLIJ=1` environment variables are set. Generate the human-readable registry with `sks features inventory --write-docs`. Plain `npm publish` uses the `latest` dist-tag. npm's `prepublishOnly` verifies the fresh release stamp instead of rerunning the full gate, and `prepack` only rebuilds `dist`; publish no longer repeats the expensive release suite during packaging. `npm run publish:dry` remains the explicit dry-run helper.
+`release:check` runs the current 1.20.x release-closure DAG, writes a source digest stamp under `.sneakoscope/reports/`, then refreshes release readiness so publish commands can verify the same stamp. The DAG preserves the 1.18 baseline gates and adds patch swarm runtime truth, transaction journaling, serial conflict rebase, strict strategy-to-patch proof, rollback command proof, Native CLI Session Swarm 5/10/20-process proof, Real Worker Backend Router proof, Codex child overlap proof, model-authored patch-envelope separation, Zellij layout/pane/screen/socket-dir proof, no-subagent-scaling proof, Fast mode default/worker/Codex/MAD propagation proof, Appshots attachment provenance, MCP runtime overlap evidence, Codex 0.134/0.135 runner truth, task graph expansion, schema-bound follow-up work, actual Agent/Team/Research/QA route blackboxes, scheduler proof hardening, Source Intelligence propagation, and Goal mode propagation checks. Broader live gates remain explicit scripts such as `release:real-check`; real Codex patch smoke, real Codex parallel worker proof, and real Zellij proof are optional unless their `SKS_REQUIRE_REAL_*` or `SKS_REQUIRE_ZELLIJ=1` environment variables are set. Generate the human-readable registry with `sks features inventory --write-docs`. Plain `npm publish` uses the `latest` dist-tag. npm's `prepublishOnly` verifies the fresh release stamp instead of rerunning the full gate, and `prepack` only rebuilds `dist`; publish no longer repeats the expensive release suite during packaging. `npm run publish:dry` remains the explicit dry-run helper.
 
 Version bumps are manual. Run `sks versioning bump` only when preparing release metadata; SKS will not create `.git/hooks/pre-commit` or auto-bump during ordinary commits.
 

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "1.20.2"
+version = "1.20.3"
 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.20.2"),
+        Some("--version") => println!("sks-rs 1.20.3"),
         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.20.2",
-  "source_digest": "d1ccddca4a2c7be54d3129554ea90f8d07efb093592c1e269399fa0e5b92d3ba",
-  "source_file_count": 1740,
-  "built_at_source_time": 1780235613612
+  "package_version": "1.20.3",
+  "source_digest": "c76562a39aaa8ecf01128ce5cda509ad6f8883d1f8c6203c73ddad1d243e54e5",
+  "source_file_count": 1743,
+  "built_at_source_time": 1780267464746
 }

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '1.20.2';
+const FAST_PACKAGE_VERSION = '1.20.3';
 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.20.2",
-  "package_version": "1.20.2",
+  "version": "1.20.3",
+  "package_version": "1.20.3",
   "typescript": true,
   "mjs_runtime_files": 0,
-  "compiled_file_count": 1016,
-  "compiled_js_count": 508,
-  "compiled_dts_count": 508,
-  "source_digest": "d1ccddca4a2c7be54d3129554ea90f8d07efb093592c1e269399fa0e5b92d3ba",
-  "source_file_count": 1740,
-  "source_files_hash": "7484278e30e61755c2158548e697943af09e5a59de7c6b60018a0ac57848c6ec",
-  "source_list_hash": "7484278e30e61755c2158548e697943af09e5a59de7c6b60018a0ac57848c6ec",
+  "compiled_file_count": 1018,
+  "compiled_js_count": 509,
+  "compiled_dts_count": 509,
+  "source_digest": "c76562a39aaa8ecf01128ce5cda509ad6f8883d1f8c6203c73ddad1d243e54e5",
+  "source_file_count": 1743,
+  "source_files_hash": "b1db64d16ef4e7f980de40d7c8c78b3280d95e78c5583092368dd283aeb367af",
+  "source_list_hash": "b1db64d16ef4e7f980de40d7c8c78b3280d95e78c5583092368dd283aeb367af",
   "src_mjs_runtime_files": 0,
   "dist_stamp_schema": "sks.dist-build-stamp.v1",
   "files": [
@@ -442,6 +442,8 @@
     "core/commands/dfix-command.js",
     "core/commands/eval-command.d.ts",
     "core/commands/eval-command.js",
+    "core/commands/fast-mode-command.d.ts",
+    "core/commands/fast-mode-command.js",
     "core/commands/gc-command.d.ts",
     "core/commands/gc-command.js",
     "core/commands/git-command.d.ts",

package/dist/cli/command-registry.d.ts

@@ -58,6 +58,7 @@ export declare const COMMANDS: {
     'dollar-commands': CommandEntry;
     dollars: CommandEntry;
     $: CommandEntry;
+    'fast-mode': CommandEntry;
     commit: CommandEntry;
     'commit-and-push': CommandEntry;
     dfix: CommandEntry;
@@ -146,6 +147,7 @@ export declare const TYPED_COMMANDS: {
     'dollar-commands': CommandEntry;
     dollars: CommandEntry;
     $: CommandEntry;
+    'fast-mode': CommandEntry;
     commit: CommandEntry;
     'commit-and-push': CommandEntry;
     dfix: CommandEntry;

package/dist/cli/command-registry.js

@@ -111,6 +111,7 @@ export const COMMANDS = {
     'dollar-commands': entry('stable', 'List Codex App dollar commands', 'dist/core/commands/basic-cli.js', basicArgs('dollarCommandsCommand')),
     dollars: entry('stable', 'Alias for dollar-commands', 'dist/core/commands/basic-cli.js', basicArgs('dollarCommandsCommand')),
     '$': entry('stable', 'Alias for dollar-commands', 'dist/core/commands/basic-cli.js', basicArgs('dollarCommandsCommand')),
+    'fast-mode': entry('stable', 'Toggle SKS Fast mode default for dollar-command routes', 'dist/core/commands/fast-mode-command.js', argsCommand(() => import('../core/commands/fast-mode-command.js'), 'fastModeCommand', 'dist/core/commands/fast-mode-command.js')),
     commit: entry('stable', 'Create a simple git commit', 'dist/commands/commit.js', directCommand(() => import('../commands/commit.js'), 'dist/commands/commit.js')),
     'commit-and-push': entry('stable', 'Create a simple git commit and push', 'dist/commands/commit-and-push.js', directCommand(() => import('../commands/commit-and-push.js'), 'dist/commands/commit-and-push.js')),
     dfix: entry('stable', 'Run DFix diagnose/plan/patch/verify loop', 'dist/core/commands/dfix-command.js', commandArgsCommand(() => import('../core/commands/dfix-command.js'), 'dfixCommand', 'dist/core/commands/dfix-command.js')),

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

@@ -12,8 +12,13 @@ export declare function run(_command: any, args?: any): Promise<void | {
     layout_artifact: string;
     command: string[];
     launch_command: string[];
+    launch_command_with_env: string;
     background_command: string[];
+    background_command_with_env: string;
     attach_command: string;
+    attach_command_with_env: string;
+    zellij_socket_dir: string | null;
+    zellij_socket_dir_source: import("../core/zellij/zellij-command.js").ZellijSocketDirSource;
     pane_proof_path: string;
     pane_proof: {
         schema: string;

package/dist/core/agents/agent-orchestrator.js

@@ -51,7 +51,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
     const route = opts.route || '$Agent';
     const routeCommand = String(opts.routeCommand || defaultRouteCommand(route));
     const routeBlackboxKind = String(opts.routeBlackboxKind || defaultRouteBlackboxKind(route));
-    const fastModePolicy = resolveFastModePolicy(opts);
+    const fastModePolicy = resolveFastModePolicy({ ...opts, root });
     const backend = normalizeAgentBackend(opts.backend || (opts.mock ? 'fake' : 'codex-exec'));
     const maxAgentCount = Number.isFinite(Number(opts.maxAgentCount)) && Number(opts.maxAgentCount) >= 1 ? Math.floor(Number(opts.maxAgentCount)) : MAX_AGENT_COUNT;
     const realZellij = backend === 'zellij' && opts.real === true;

package/dist/core/agents/fast-mode-policy.d.ts

@@ -1,18 +1,45 @@
 export declare const FAST_MODE_POLICY_SCHEMA = "sks.fast-mode-policy.v1";
 export declare const FAST_MODE_PROPAGATION_PROOF_SCHEMA = "sks.fast-mode-propagation-proof.v1";
+export declare const FAST_MODE_PREFERENCE_SCHEMA = "sks.fast-mode-preference.v1";
 export type AgentServiceTier = 'fast' | 'standard';
+export type FastModePreferenceMode = AgentServiceTier;
 export interface FastModePolicy {
     schema: typeof FAST_MODE_POLICY_SCHEMA;
     generated_at: string;
     fast_mode: boolean;
     service_tier: AgentServiceTier;
     default_fast_mode: true;
-    disabled_by: 'none' | 'no-fast' | 'service-tier-standard';
+    disabled_by: 'none' | 'no-fast' | 'service-tier-standard' | 'preference-standard';
     explicit_fast: boolean;
     explicit_no_fast: boolean;
     explicit_service_tier: AgentServiceTier | null;
+    preference_mode: FastModePreferenceMode | null;
+    preference_path: string | null;
+    preference_source: 'project-state' | null;
+}
+export interface FastModePreference {
+    schema: typeof FAST_MODE_PREFERENCE_SCHEMA;
+    updated_at: string;
+    mode: FastModePreferenceMode;
+    fast_mode: boolean;
+    service_tier: AgentServiceTier;
+    source: string;
 }
 export declare function resolveFastModePolicy(input?: any): FastModePolicy;
+export declare function fastModePreferencePath(root?: string): string;
+export declare function readFastModePreferenceSync(root?: string | null): (FastModePreference & {
+    path: string;
+}) | null;
+export declare function readFastModePreference(root?: string): Promise<(FastModePreference & {
+    path: string;
+}) | null>;
+export declare function writeFastModePreference(root: string | undefined, mode: FastModePreferenceMode, source?: string): Promise<FastModePreference & {
+    path: string;
+}>;
+export declare function clearFastModePreference(root?: string): Promise<{
+    path: string;
+    removed: boolean;
+}>;
 export declare function fastModeEnv(policy: FastModePolicy): NodeJS.ProcessEnv;
 export declare function applyFastModeToRoster<T extends Record<string, any>>(roster: T, policy: FastModePolicy): T;
 export declare function writeFastModePropagationProof(root: string, input?: {

package/dist/core/agents/fast-mode-policy.js

@@ -1,29 +1,85 @@
+import fsSync from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { nowIso, readJson, writeJsonAtomic } from '../fsx.js';
 export const FAST_MODE_POLICY_SCHEMA = 'sks.fast-mode-policy.v1';
 export const FAST_MODE_PROPAGATION_PROOF_SCHEMA = 'sks.fast-mode-propagation-proof.v1';
+export const FAST_MODE_PREFERENCE_SCHEMA = 'sks.fast-mode-preference.v1';
 export function resolveFastModePolicy(input = {}) {
     const explicitTier = normalizeServiceTier(input.serviceTier ?? input.service_tier, null);
     const explicitNoFast = input.fastMode === false || input.fast_mode === false || input.noFast === true || input.no_fast === true;
     const explicitFast = input.fastMode === true || input.fast_mode === true || input.fast === true;
+    const preference = explicitNoFast || explicitFast || explicitTier
+        ? null
+        : readFastModePreferenceSync(input.preferenceRoot || input.preference_root || input.root);
     const serviceTier = explicitNoFast
         ? 'standard'
         : explicitTier === 'standard'
             ? 'standard'
-            : 'fast';
+            : preference?.mode === 'standard'
+                ? 'standard'
+                : 'fast';
     return {
         schema: FAST_MODE_POLICY_SCHEMA,
         generated_at: nowIso(),
         fast_mode: serviceTier === 'fast',
         service_tier: serviceTier,
         default_fast_mode: true,
-        disabled_by: explicitNoFast ? 'no-fast' : serviceTier === 'standard' ? 'service-tier-standard' : 'none',
+        disabled_by: explicitNoFast ? 'no-fast' : explicitTier === 'standard' ? 'service-tier-standard' : preference?.mode === 'standard' ? 'preference-standard' : 'none',
         explicit_fast: explicitFast,
         explicit_no_fast: explicitNoFast,
-        explicit_service_tier: explicitTier
+        explicit_service_tier: explicitTier,
+        preference_mode: preference?.mode || null,
+        preference_path: preference?.path || null,
+        preference_source: preference ? 'project-state' : null
     };
 }
+export function fastModePreferencePath(root = process.cwd()) {
+    return path.join(path.resolve(root), '.sneakoscope', 'state', 'fast-mode.json');
+}
+export function readFastModePreferenceSync(root) {
+    if (!root)
+        return null;
+    const file = fastModePreferencePath(root);
+    try {
+        const parsed = JSON.parse(fsSync.readFileSync(file, 'utf8'));
+        const mode = normalizeServiceTier(parsed?.mode ?? parsed?.service_tier, null);
+        if (!mode)
+            return null;
+        return normalizeFastModePreference({ ...parsed, mode }, file);
+    }
+    catch {
+        return null;
+    }
+}
+export async function readFastModePreference(root = process.cwd()) {
+    const file = fastModePreferencePath(root);
+    const parsed = await readJson(file, null);
+    const mode = normalizeServiceTier(parsed?.mode ?? parsed?.service_tier, null);
+    if (!mode)
+        return null;
+    return normalizeFastModePreference({ ...parsed, mode }, file);
+}
+export async function writeFastModePreference(root = process.cwd(), mode, source = 'sks fast-mode') {
+    const normalized = normalizeServiceTier(mode, 'fast') || 'fast';
+    const file = fastModePreferencePath(root);
+    const preference = {
+        schema: FAST_MODE_PREFERENCE_SCHEMA,
+        updated_at: nowIso(),
+        mode: normalized,
+        fast_mode: normalized === 'fast',
+        service_tier: normalized,
+        source
+    };
+    await writeJsonAtomic(file, preference);
+    return { ...preference, path: file };
+}
+export async function clearFastModePreference(root = process.cwd()) {
+    const file = fastModePreferencePath(root);
+    const existed = fsSync.existsSync(file);
+    await fs.rm(file, { force: true }).catch(() => { });
+    return { path: file, removed: existed };
+}
 export function fastModeEnv(policy) {
     return {
         SKS_FAST_MODE: policy.fast_mode ? '1' : '0',
@@ -114,6 +170,18 @@ function normalizeServiceTier(value, fallback = 'fast') {
         return text;
     return fallback;
 }
+function normalizeFastModePreference(parsed, file) {
+    const mode = normalizeServiceTier(parsed?.mode ?? parsed?.service_tier, 'fast') || 'fast';
+    return {
+        schema: FAST_MODE_PREFERENCE_SCHEMA,
+        updated_at: typeof parsed?.updated_at === 'string' ? parsed.updated_at : nowIso(),
+        mode,
+        fast_mode: mode === 'fast',
+        service_tier: mode,
+        source: typeof parsed?.source === 'string' ? parsed.source : 'unknown',
+        path: file
+    };
+}
 function normalizeReasoningProfile(value, policy) {
     const profile = String(value || 'sks-agent-medium-fast');
     return policy.fast_mode ? profile.replace(/-standard$/, '-fast') : profile.replace(/-fast$/, '-standard');

package/dist/core/commands/fast-mode-command.d.ts

@@ -0,0 +1,28 @@
+export declare const FAST_MODE_COMMAND_SCHEMA = "sks.fast-mode-command.v1";
+export declare function fastModeCommand(args?: string[]): Promise<void | {
+    schema: string;
+    ok: boolean;
+    action: "off" | "clear" | "on" | "status";
+    root: string;
+    state_path: string;
+    preference: (import("../agents/fast-mode-policy.js").FastModePreference & {
+        path: string;
+    }) | null;
+    removed: boolean | null;
+    fast_mode: boolean;
+    service_tier: import("../agents/fast-mode-policy.js").AgentServiceTier;
+    disabled_by: "none" | "no-fast" | "service-tier-standard" | "preference-standard";
+    policy: import("../agents/fast-mode-policy.js").FastModePolicy;
+    dollar_commands: {
+        on: string;
+        off: string;
+        status: string;
+    };
+    cli_commands: {
+        on: string;
+        off: string;
+        clear: string;
+        status: string;
+    };
+}>;
+//# sourceMappingURL=fast-mode-command.d.ts.map

package/dist/core/commands/fast-mode-command.js

@@ -0,0 +1,81 @@
+import path from 'node:path';
+import { flag } from '../../cli/args.js';
+import { printJson } from '../../cli/output.js';
+import { projectRoot } from '../fsx.js';
+import { clearFastModePreference, fastModePreferencePath, readFastModePreference, resolveFastModePolicy, writeFastModePreference } from '../agents/fast-mode-policy.js';
+export const FAST_MODE_COMMAND_SCHEMA = 'sks.fast-mode-command.v1';
+export async function fastModeCommand(args = []) {
+    const action = normalizeFastModeAction(args[0]);
+    const root = path.resolve(String(readOption(args, '--root', '') || await projectRoot()));
+    const statePath = fastModePreferencePath(root);
+    let preference = await readFastModePreference(root);
+    let removed = null;
+    if (action === 'on' || action === 'off') {
+        const mode = action === 'on' ? 'fast' : 'standard';
+        preference = await writeFastModePreference(root, mode, `sks fast-mode ${action}`);
+    }
+    else if (action === 'clear') {
+        const result = await clearFastModePreference(root);
+        removed = result.removed;
+        preference = null;
+    }
+    const policy = resolveFastModePolicy({ root });
+    const result = {
+        schema: FAST_MODE_COMMAND_SCHEMA,
+        ok: true,
+        action,
+        root,
+        state_path: statePath,
+        preference,
+        removed,
+        fast_mode: policy.fast_mode,
+        service_tier: policy.service_tier,
+        disabled_by: policy.disabled_by,
+        policy,
+        dollar_commands: {
+            on: '$Fast-On',
+            off: '$Fast-Off',
+            status: '$Fast-Mode'
+        },
+        cli_commands: {
+            on: 'sks fast-mode on',
+            off: 'sks fast-mode off',
+            clear: 'sks fast-mode clear',
+            status: 'sks fast-mode status'
+        }
+    };
+    if (flag(args, '--json'))
+        return printJson(result);
+    console.log('SKS Fast Mode');
+    console.log(`Root: ${root}`);
+    console.log(`Status: ${result.fast_mode ? 'on' : 'off'} (service_tier=${result.service_tier})`);
+    console.log(`State: ${path.relative(root, statePath)}`);
+    if (action === 'on')
+        console.log('Saved: fast mode on');
+    else if (action === 'off')
+        console.log('Saved: fast mode off');
+    else if (action === 'clear')
+        console.log(`Cleared: ${removed ? 'yes' : 'already default'}`);
+    else if (!preference)
+        console.log('Preference: default fast');
+    console.log('Dollar: $Fast-On | $Fast-Off | $Fast-Mode');
+    return result;
+}
+function normalizeFastModeAction(value) {
+    const text = String(value || 'status').toLowerCase();
+    if (['on', 'enable', 'enabled', 'fast'].includes(text))
+        return 'on';
+    if (['off', 'disable', 'disabled', 'standard', 'slow'].includes(text))
+        return 'off';
+    if (['clear', 'default', 'reset'].includes(text))
+        return 'clear';
+    return 'status';
+}
+function readOption(args = [], name, fallback = null) {
+    const index = args.indexOf(name);
+    if (index >= 0 && args[index + 1] && !String(args[index + 1]).startsWith('--'))
+        return args[index + 1];
+    const prefixed = args.find((arg) => String(arg).startsWith(name + '='));
+    return prefixed ? prefixed.slice(name.length + 1) : fallback;
+}
+//# sourceMappingURL=fast-mode-command.js.map

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

@@ -12,8 +12,13 @@ export declare function madHighCommand(args?: any, deps?: any): Promise<void | {
     layout_artifact: string;
     command: string[];
     launch_command: string[];
+    launch_command_with_env: string;
     background_command: string[];
+    background_command_with_env: string;
     attach_command: string;
+    attach_command_with_env: string;
+    zellij_socket_dir: string | null;
+    zellij_socket_dir_source: import("../zellij/zellij-command.js").ZellijSocketDirSource;
     pane_proof_path: string;
     pane_proof: {
         schema: string;

package/dist/core/commands/run-command.js

@@ -231,7 +231,7 @@ async function executeRouteCommand(root, route, prompt, { auto = false } = {}) {
     return routeExecutionResult(route, ['sks', ...commandArgs].join(' '), result, {
         okStatus: 'completed',
         trustStatus: 'verified_partial',
-        executionKind: route.command === '$DB' || route.command === '$Wiki' ? 'safe_deterministic' : 'mock_safe',
+        executionKind: route.command === '$DB' || route.command === '$Wiki' || route.command === '$Fast-Mode' ? 'safe_deterministic' : 'mock_safe',
     });
 }
 async function runAutoVerification(root, missionId) {
@@ -344,8 +344,34 @@ function safeRouteExecutionArgs(route, prompt, { auto = false } = {}) {
         return ['db', 'check', '--sql', 'SELECT 1', '--json'];
     if (route.command === '$Wiki')
         return ['wiki', 'refresh', '--json'];
+    if (route.command === '$Fast-Mode')
+        return ['fast-mode', fastModeActionFromPrompt(prompt), '--json'];
     return ['team', prompt, '--mock', '--json', ...(auto ? ['--no-open-zellij'] : [])];
 }
+function fastModeActionFromPrompt(prompt = '') {
+    const text = String(prompt || '');
+    const lower = text.toLowerCase();
+    if (/\$fast-off\b/.test(lower))
+        return 'off';
+    if (/\$fast-on\b/.test(lower))
+        return 'on';
+    const routeMatch = /\$fast-mode\b/i.exec(text);
+    if (!routeMatch)
+        return 'status';
+    const afterRoute = text
+        .slice(routeMatch.index + routeMatch[0].length)
+        .replace(/^[\s:=\-]+/, '')
+        .trimStart()
+        .toLowerCase();
+    const token = afterRoute.match(/^[^\s?!.,;:()"'`]+/)?.[0] || '';
+    if (['off', 'disable', 'disabled', 'standard', 'slow', '끄기', '꺼', '꺼줘'].includes(token) || token.startsWith('끄') || token.startsWith('꺼'))
+        return 'off';
+    if (['on', 'enable', 'enabled', 'fast', '켜기', '켜', '켜줘'].includes(token) || token.startsWith('켜'))
+        return 'on';
+    if (['clear', 'reset', 'default', '초기화', '기본'].includes(token) || token.startsWith('초기화'))
+        return 'clear';
+    return 'status';
+}
 function destructiveDbPrompt(prompt = '') {
     return /\b(drop|truncate|delete\s+from|update\s+\w+\s+set|reset|db\s+push|disable\s+rls)\b/i.test(prompt);
 }

package/dist/core/feature-fixtures.js

@@ -54,6 +54,7 @@ const FIXTURES = Object.freeze({
     'cli-memory': fixture('execute', 'sks memory --dry-run --json', [], 'pass'),
     'cli-stats': fixture('execute', 'sks stats --json', [], 'pass'),
     'cli-dollar-commands': fixture('execute', 'sks dollar-commands --json', [], 'pass'),
+    'cli-fast-mode': fixture('execute', 'sks fast-mode status --json', [], 'pass'),
     'cli-dfix': fixture('execute_and_validate_artifacts', 'sks dfix fixture --json', ['completion-proof.json', 'dfix-gate.json', 'dfix-verification.json'], 'pass'),
     'cli-wiki': fixture('execute_and_validate_artifacts', 'sks wiki image-ingest test/fixtures/images/one-by-one.png --json', [{ path: '.sneakoscope/wiki/image-voxel-ledger.json', schema: 'sks.image-voxel-ledger.v1', require_anchors: false }], 'pass'),
     'cli-db': fixture('execute', 'sks db policy', [], 'pass'),
@@ -106,6 +107,9 @@ const FIXTURES = Object.freeze({
     'route-wiki': fixture('execute_and_validate_artifacts', 'sks wiki image-ingest test/fixtures/images/one-by-one.png --json', [{ path: 'completion-proof.json', schema: 'sks.completion-proof.v1' }, { path: 'image-voxel-ledger.json', schema: 'sks.image-voxel-ledger.v1' }], 'pass'),
     'route-gx': fixture('execute_and_validate_artifacts', 'sks gx validate fixture --mock --json', ['completion-proof.json', { path: 'image-voxel-ledger.json', schema: 'sks.image-voxel-ledger.v1' }, 'gx-validation.json'], 'pass'),
     'route-sks': fixture('mock', '$SKS control-surface route', ['completion-proof.json'], 'pass'),
+    'route-fast-mode': fixture('execute', 'sks fast-mode status --json', [], 'pass'),
+    'route-fast-on': fixture('mock', '$Fast-On covered by hermetic fast-mode blackbox toggle test', [], 'pass'),
+    'route-fast-off': fixture('mock', '$Fast-Off covered by hermetic fast-mode blackbox toggle test', [], 'pass'),
     'route-help': fixture('mock', '$Help lightweight route', [], 'pass'),
     'route-commit': fixture('mock', '$Commit git route', ['completion-proof.json'], 'pass'),
     'route-commit-and-push': fixture('mock', '$Commit-And-Push git route', ['completion-proof.json'], 'pass'),

package/dist/core/feature-registry.js

@@ -479,6 +479,7 @@ const SAFE_EXECUTABLE_FIXTURE_ARGS = Object.freeze({
     'cli-memory': ['memory', '--dry-run', '--json'],
     'cli-stats': ['stats', '--json'],
     'cli-dollar-commands': ['dollar-commands', '--json'],
+    'cli-fast-mode': ['fast-mode', 'status', '--json'],
     'cli-dfix': ['dfix', 'fixture', '--json'],
     'cli-all-features': ['all-features', 'complete', '--json'],
     'route-team': ['team', 'fixture', '--mock', '--json'],
@@ -489,6 +490,7 @@ const SAFE_EXECUTABLE_FIXTURE_ARGS = Object.freeze({
     'route-image-ux-review': ['image-ux-review', 'fixture', '--mock', '--json'],
     'route-computer-use': ['computer-use', 'import-fixture', '--mock', '--json'],
     'route-dfix': ['dfix', 'fixture', '--json'],
+    'route-fast-mode': ['fast-mode', 'status', '--json'],
     'route-db': ['db', 'check', '--sql', 'SELECT 1', '--json'],
     'route-wiki': ['wiki', 'image-ingest', 'test/fixtures/images/one-by-one.png', '--json'],
     'route-gx': ['gx', 'validate', 'fixture', '--mock', '--json']
@@ -817,14 +819,14 @@ function commandCategory(name) {
     return 'core-cli';
 }
 function commandMaturity(name) {
-    if (['help', 'version', 'commands', 'usage', 'root', 'quickstart', 'setup', 'doctor', 'selftest', 'update-check'].includes(name))
+    if (['help', 'version', 'commands', 'usage', 'root', 'quickstart', 'setup', 'doctor', 'selftest', 'update-check', 'fast-mode'].includes(name))
         return 'stable';
     if (['codex', 'codex-app', 'codex-lb', 'hooks', 'features', 'all-features', 'wiki', 'wrongness', 'team', 'pipeline', 'goal', 'db', 'guard'].includes(name))
         return 'beta';
     return 'labs';
 }
 function routeMaturity(command) {
-    if (['$Answer', '$DFix', '$SKS', '$Wiki', '$Help'].includes(command))
+    if (['$Answer', '$DFix', '$SKS', '$Fast-Mode', '$Wiki', '$Help'].includes(command))
         return 'stable';
     if (['$Team', '$Goal', '$DB', '$Computer-Use', '$CU', '$QA-LOOP', '$MAD-SKS'].includes(command))
         return 'beta';

package/dist/core/fsx.d.ts

@@ -1,4 +1,4 @@
-export declare const PACKAGE_VERSION = "1.20.2";
+export declare const PACKAGE_VERSION = "1.20.3";
 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.20.2';
+export const PACKAGE_VERSION = '1.20.3';
 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

@@ -1035,6 +1035,9 @@ export async function installSkills(root) {
         'dfix': `---\nname: dfix\ndescription: Direct Fix mode for $DFix or $dfix requests and inferred tiny copy/config/docs/labels/spacing/translation/simple mechanical edits.\n---\n\nUse for tiny copy/config/docs/labels/spacing/translation/simple mechanical edits. List exact micro-edits, inspect only needed files, apply only those edits, and run cheap verification. Keep broad implementation routed to Team; for UI/UX micro-edits read \`design.md\` when present and use imagegen for image/logo/raster assets. Bypass broad SKS routing, mission state, TriWiki/TriFix/reflection/state recording, Goal, Research, eval, redesign, and repeated full-route Honest Mode loops. Start the final answer with \`DFix 완료 요약:\` and include one \`DFix 솔직모드:\` line covering verified, not verified, and remaining issues. ${CODEX_IMAGEGEN_REQUIRED_POLICY}\n`,
         'answer': `---\nname: answer\ndescription: Answer-only research route for ordinary questions that should not start implementation.\n---\n\nUse for explanations, comparisons, status, facts, source-backed research, or docs guidance. Use repo/TriWiki first for project-local facts; hydrate low-trust claims from source. Browse or use Context7 for current external package/API/framework/MCP docs. End with a concise answer summary plus Honest Mode; do not create missions, subagents, or file edits.\n`,
         'sks': `---\nname: sks\ndescription: General Sneakoscope Codex command route for $SKS or $sks usage, setup, status, and workflow help.\n---\n\nUse local SKS commands: bootstrap, deps, commands, quickstart, codex-app, context7, guard, conflicts, reasoning, wiki, pipeline status, pipeline plan, skill-dream. Promote code-changing work to Team unless Answer/DFix/Help/Wiki/safety route fits. Surface route/guard/scope, use TriWiki, do not edit installed harness files outside this engine repo, and require human-approved conflict cleanup. ${skillDreamPolicyText()}\n`,
+        'fast-mode': `---\nname: fast-mode\ndescription: Dollar-command route for $Fast-Mode, $Fast-On, and $Fast-Off project-local Fast mode toggles.\n---\n\nUse when the user invokes $Fast-Mode, $Fast-On, $Fast-Off, or asks to turn SKS Fast mode on/off for dollar commands. Prefer \`sks fast-mode on|off|status|clear --json\`. The command writes only .sneakoscope/state/fast-mode.json in the active project. Explicit runtime flags still win: \`--fast\`, \`--no-fast\`, and \`--service-tier standard|fast\` override the saved preference for that run. Finish with a short status and Honest Mode; do not start Team or broad implementation for a toggle-only request.\n`,
+        'fast-on': `---\nname: fast-on\ndescription: Alias for $Fast-On project-local SKS Fast mode enablement.\n---\n\nUse the same rules as fast-mode. Run or instruct \`sks fast-mode on --json\`, then report the active state, state file, and the fact that explicit per-run flags still override the saved preference.\n`,
+        'fast-off': `---\nname: fast-off\ndescription: Alias for $Fast-Off project-local SKS Fast mode disablement.\n---\n\nUse the same rules as fast-mode. Run or instruct \`sks fast-mode off --json\`, then report the active state, state file, and the fact that explicit per-run flags still override the saved preference.\n`,
         'wiki': `---\nname: wiki\ndescription: Dollar-command route for $Wiki TriWiki refresh, pack, validate, and prune commands.\n---\n\nUse for $Wiki or Korean wiki-refresh requests. Refresh/update/갱신: run sks wiki refresh, then validate .sneakoscope/wiki/context-pack.json. Pack: run sks wiki pack, then validate. Prune/clean/정리: use sks wiki refresh --prune, or sks wiki prune --dry-run for inspection. Report claims, anchors, trust, attention.use_first/hydrate_first, validation, and blockers. Do not start ambiguity-gated implementation, subagents, or unrelated work.\n`,
         'team': `---\nname: team\ndescription: SKS Team orchestration for $Team/code work; $From-Chat-IMG is the explicit chat-image alias.\n---\n\nUse for $Team/code work. Auto-seal the route contract from prompt, TriWiki/current-code defaults, and conservative policy; do not surface a prequestion sheet. Read pipeline-plan.json or run sks pipeline plan to see the runtime lane, kept/skipped stages, and verification before implementation. Write team-roster.json; team-gate.json needs team_roster_confirmed=true. executor:N means N native analysis agents, N debate voices, then fresh N executors. ${MIN_TEAM_REVIEW_POLICY_TEXT} After consensus, compile team-graph.json, team-runtime-tasks.json, team-decomposition-report.json, and team-inbox/ so worker handoff uses concrete runtime task ids with role/path/domain/lane hints. Refresh/validate TriWiki before debate, implementation, review, and final; consume attention.use_first and hydrate attention.hydrate_first before risky decisions. ${outcomeRubricPolicyText()} ${speedLanePolicyText()} ${solutionScoutPolicyText('fix this broken behavior')} ${skillDreamPolicyText()} Log events and use sks team message for bounded inter-agent communication in transcript/lane panes. Color-coded Zellij lanes distinguish overview/native-analysis/planning/execution/review/safety sessions in one Zellij window using split panes when Zellij is available. $Team/$team plus sks --mad uses the MAD-SKS permission gate module: user-authorized target-project scopes such as files, shell, packages, services, network, browser/Computer Use, generated assets, file permissions, migrations, normal DB writes, Supabase MCP writes, direct SQL, and schema cleanup are open only for the active invocation; catastrophic wipe/all-row/project-management, credential exfiltration, persistent security weakening, and unrequested fallback guards remain. End with cleanup-zellij or a cleanup event so follow panes show cleanup and stop; pass team-session-cleanup.json, then reflection and Honest Mode. Parent integrates/verifies.\n\n${chatCaptureIntakeText()}\n`,
         'from-chat-img': `---\nname: from-chat-img\ndescription: Explicit $From-Chat-IMG Team alias for chat screenshot plus attachment analysis.\n---\n\nUse only for From-Chat-IMG/$From-Chat-IMG. It enters the normal Team pipeline. Treat uploads as chat screenshot plus originals. For web/browser/webapp targets use Codex Chrome Extension first; for native Mac/non-web app surfaces use Codex Computer Use visual inspection when available. List requirements first, match regions to attachments with confidence, write ${FROM_CHAT_IMG_COVERAGE_ARTIFACT}, ${FROM_CHAT_IMG_CHECKLIST_ARTIFACT}, ${FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT}, and ${FROM_CHAT_IMG_QA_LOOP_ARTIFACT}, then continue Team gates, review, reflection, and Honest Mode. ${CODEX_WEB_VERIFICATION_POLICY} ${CODEX_COMPUTER_USE_ONLY_POLICY} The ledger must account for every visible customer request, screenshot image region, and separate attachment; ${FROM_CHAT_IMG_CHECKLIST_ARTIFACT} must have a checked item for each request, image-region/attachment match, work item, scoped QA-LOOP, and verification step; ${FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT} stores temporary TriWiki-backed session context with expires_after_sessions=${FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS}. ${FROM_CHAT_IMG_QA_LOOP_ARTIFACT} must prove QA-LOOP ran over the exact customer-request work-order range after implementation, with every work item covered, post-fix verification complete, and zero unresolved findings. team-gate.json cannot pass From-Chat-IMG completion until unresolved_items is empty, every checklist box is checked, and scoped_qa_loop_completed=true.\n`,

package/dist/core/routes.d.ts

@@ -10,7 +10,7 @@ export declare const FROM_CHAT_IMG_CHECKLIST_ARTIFACT = "from-chat-img-checklist
 export declare const FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT = "from-chat-img-temp-triwiki.json";
 export declare const FROM_CHAT_IMG_QA_LOOP_ARTIFACT = "from-chat-img-qa-loop.json";
 export declare const FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS = 5;
-export declare const USAGE_TOPICS = "install|setup|bootstrap|root|deps|zellij|tmux|auto-review|team|qa-loop|ppt|image-ux-review|goal|research|db|git|codex|codex-app|hooks|features|all-features|openclaw|hermes|dfix|commit|commit-and-push|design|imagegen|dollar|context7|pipeline|reasoning|guard|conflicts|versioning|eval|harness|hproof|gx|wiki|wrongness|code-structure|proof-field|skill-dream|rust";
+export declare const USAGE_TOPICS = "install|setup|bootstrap|root|deps|zellij|tmux|auto-review|team|qa-loop|ppt|image-ux-review|goal|fast-mode|research|db|git|codex|codex-app|hooks|features|all-features|openclaw|hermes|dfix|commit|commit-and-push|design|imagegen|dollar|context7|pipeline|reasoning|guard|conflicts|versioning|eval|harness|hproof|gx|wiki|wrongness|code-structure|proof-field|skill-dream|rust";
 export declare const CODEX_COMPUTER_USE_EVIDENCE_SOURCE = "codex_computer_use";
 export declare const CODEX_WEB_VERIFICATION_EVIDENCE_SOURCE = "codex_chrome_extension";
 export declare const CODEX_IMAGEGEN_EVIDENCE_SOURCE = "codex_app_imagegen_gpt_image_2";

package/dist/core/routes.js

@@ -28,7 +28,7 @@ export const FROM_CHAT_IMG_CHECKLIST_ARTIFACT = 'from-chat-img-checklist.md';
 export const FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT = 'from-chat-img-temp-triwiki.json';
 export const FROM_CHAT_IMG_QA_LOOP_ARTIFACT = 'from-chat-img-qa-loop.json';
 export const FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS = 5;
-export const USAGE_TOPICS = 'install|setup|bootstrap|root|deps|zellij|tmux|auto-review|team|qa-loop|ppt|image-ux-review|goal|research|db|git|codex|codex-app|hooks|features|all-features|openclaw|hermes|dfix|commit|commit-and-push|design|imagegen|dollar|context7|pipeline|reasoning|guard|conflicts|versioning|eval|harness|hproof|gx|wiki|wrongness|code-structure|proof-field|skill-dream|rust';
+export const USAGE_TOPICS = 'install|setup|bootstrap|root|deps|zellij|tmux|auto-review|team|qa-loop|ppt|image-ux-review|goal|fast-mode|research|db|git|codex|codex-app|hooks|features|all-features|openclaw|hermes|dfix|commit|commit-and-push|design|imagegen|dollar|context7|pipeline|reasoning|guard|conflicts|versioning|eval|harness|hproof|gx|wiki|wrongness|code-structure|proof-field|skill-dream|rust';
 export const CODEX_COMPUTER_USE_EVIDENCE_SOURCE = 'codex_computer_use';
 export const CODEX_WEB_VERIFICATION_EVIDENCE_SOURCE = 'codex_chrome_extension';
 export const CODEX_IMAGEGEN_EVIDENCE_SOURCE = 'codex_app_imagegen_gpt_image_2';
@@ -319,6 +319,22 @@ export const ROUTES = [
         cliEntrypoint: 'sks commands',
         examples: ['$SKS show me available workflows']
     },
+    {
+        id: 'FastMode',
+        command: '$Fast-Mode',
+        mode: 'FAST_MODE',
+        route: 'fast-mode toggle',
+        description: 'Turn the SKS Fast mode default on or off for project-local dollar-command and native-agent routes. Explicit --fast, --no-fast, and --service-tier flags still override it.',
+        requiredSkills: ['fast-mode', 'honest-mode'],
+        dollarAliases: ['$Fast-On', '$Fast-Off'],
+        appSkillAliases: ['fast-on', 'fast-off'],
+        lifecycle: ['project_state_toggle', 'policy_status', 'honest_mode'],
+        context7Policy: 'not_required',
+        reasoningPolicy: 'low',
+        stopGate: 'none',
+        cliEntrypoint: 'sks fast-mode on|off|status|clear [--json]',
+        examples: ['$Fast-On', '$Fast-Off', '$Fast-Mode status']
+    },
     {
         id: 'Team',
         command: '$Team',
@@ -604,6 +620,7 @@ export const COMMAND_CATALOG = [
     { name: 'mad', usage: 'sks --mad [--high]', description: 'Open a one-shot Zellij Codex CLI workspace with the SKS MAD full-access auto-review profile.' },
     { name: 'auto-review', usage: 'sks auto-review status|enable|start [--high] | sks --Auto-review --high', description: 'Enable Codex automatic approval review and launch SKS Zellij with the auto-review profile.' },
     { name: 'dollar-commands', usage: 'sks dollar-commands [--json]', description: 'List Codex App $ commands such as $DFix and $Team.' },
+    { name: 'fast-mode', usage: 'sks fast-mode on|off|status|clear [--json]', description: 'Toggle the project-local Fast mode default used by $Fast-On, $Fast-Off, and native-agent routes.' },
     { name: 'commit', usage: 'sks commit [--message "msg"] [--json]', description: 'Stage current changes, summarize them, and create a simple git commit without the full SKS pipeline.' },
     { name: 'commit-and-push', usage: 'sks commit-and-push [--message "msg"] [--json]', description: 'Stage current changes, create a simple git commit, and push without the full SKS pipeline.' },
     { name: 'dfix', usage: 'sks dfix', description: 'Explain $DFix ultralight direct-fix mode.' },

package/dist/core/version.d.ts

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

package/dist/core/version.js

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

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

@@ -1,4 +1,11 @@
 import { type RunProcessOptions } from '../fsx.js';
+export declare const ZELLIJ_UNIX_SOCKET_PATH_LIMIT = 103;
+export type ZellijSocketDirSource = 'env' | 'sks_env' | 'sks_default' | 'none';
+export interface ZellijProcessEnvMeta {
+    zellij_socket_dir: string | null;
+    zellij_socket_dir_source: ZellijSocketDirSource;
+    zellij_socket_path_limit: number | null;
+}
 export interface ZellijCommandResult {
     ok: boolean;
     command: 'zellij';
@@ -11,6 +18,7 @@ export interface ZellijCommandResult {
     stderr_bytes: number;
     timed_out: boolean;
     duration_ms: number;
+    env: ZellijProcessEnvMeta;
     blockers: string[];
     warnings: string[];
 }
@@ -18,6 +26,16 @@ export interface ZellijRunOptions extends Pick<RunProcessOptions, 'cwd' | 'env'
     optional?: boolean;
 }
 export declare function runZellij(args?: readonly string[], opts?: ZellijRunOptions): Promise<ZellijCommandResult>;
+export declare function prepareZellijProcessEnv(envOverrides?: NodeJS.ProcessEnv): Promise<{
+    env: NodeJS.ProcessEnv;
+    meta: ZellijProcessEnvMeta;
+    warnings: string[];
+}>;
+export declare function resolveZellijProcessEnvMeta(env?: NodeJS.ProcessEnv): ZellijProcessEnvMeta;
+export declare function defaultZellijSocketDir(): string;
+export declare function estimateZellijSocketPathLength(socketDir: string, sessionName?: string): number;
+export declare function formatZellijCommand(args?: readonly string[], meta?: ZellijProcessEnvMeta): string;
+export declare function isZellijSocketPathTooLong(text: unknown): boolean;
 export declare function parseZellijVersionText(text: unknown): string | null;
 export declare function compareVersionLike(a: unknown, b: unknown): number;
 //# sourceMappingURL=zellij-command.d.ts.map

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

@@ -1,13 +1,17 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
 import { runProcess } from '../fsx.js';
+export const ZELLIJ_UNIX_SOCKET_PATH_LIMIT = 103;
 export async function runZellij(args = [], opts = {}) {
     const started = Date.now();
+    const preparedEnv = await prepareZellijProcessEnv(opts.env);
     const runOpts = {
         cwd: opts.cwd || process.cwd(),
         timeoutMs: opts.timeoutMs ?? 10000,
         maxOutputBytes: opts.maxOutputBytes ?? 64 * 1024
     };
-    if (opts.env !== undefined)
-        runOpts.env = opts.env;
+    if (Object.keys(preparedEnv.env).length > 0)
+        runOpts.env = preparedEnv.env;
     if (opts.stdoutFile !== undefined)
         runOpts.stdoutFile = opts.stdoutFile;
     if (opts.stderrFile !== undefined)
@@ -16,6 +20,7 @@ export async function runZellij(args = [], opts = {}) {
     const ok = result.code === 0;
     const stderr = String(result.stderr || '');
     const missing = result.code === -1 && /ENOENT|not found|spawn zellij/i.test(stderr);
+    const socketPathTooLong = isZellijSocketPathTooLong(stderr);
     return {
         ok,
         command: 'zellij',
@@ -28,10 +33,60 @@ export async function runZellij(args = [], opts = {}) {
         stderr_bytes: result.stderrBytes,
         timed_out: result.timedOut,
         duration_ms: Date.now() - started,
-        blockers: ok ? [] : [missing ? 'zellij_missing' : result.timedOut ? 'zellij_command_timeout' : 'zellij_command_failed'],
-        warnings: ok || opts.optional !== true ? [] : ['zellij_command_failed_optional']
+        env: preparedEnv.meta,
+        blockers: ok ? [] : [missing ? 'zellij_missing' : socketPathTooLong ? 'zellij_socket_path_too_long' : result.timedOut ? 'zellij_command_timeout' : 'zellij_command_failed'],
+        warnings: [
+            ...preparedEnv.warnings,
+            ...(ok || opts.optional !== true ? [] : ['zellij_command_failed_optional'])
+        ]
     };
 }
+export async function prepareZellijProcessEnv(envOverrides = {}) {
+    const mergedEnv = { ...process.env, ...envOverrides };
+    const meta = resolveZellijProcessEnvMeta(mergedEnv);
+    const env = { ...envOverrides };
+    const warnings = [];
+    if (meta.zellij_socket_dir && !env.ZELLIJ_SOCKET_DIR)
+        env.ZELLIJ_SOCKET_DIR = meta.zellij_socket_dir;
+    if (meta.zellij_socket_dir) {
+        try {
+            await fs.mkdir(meta.zellij_socket_dir, { recursive: true, mode: 0o700 });
+            await fs.chmod(meta.zellij_socket_dir, 0o700).catch(() => { });
+        }
+        catch (err) {
+            warnings.push(`zellij_socket_dir_prepare_failed:${err?.code || err?.message || String(err)}`);
+        }
+    }
+    return { env, meta, warnings };
+}
+export function resolveZellijProcessEnvMeta(env = process.env) {
+    const explicit = nonEmpty(env.ZELLIJ_SOCKET_DIR);
+    if (explicit)
+        return socketMeta(explicit, 'env');
+    const sks = nonEmpty(env.SKS_ZELLIJ_SOCKET_DIR);
+    if (sks)
+        return socketMeta(sks, 'sks_env');
+    if (process.platform === 'win32') {
+        return { zellij_socket_dir: null, zellij_socket_dir_source: 'none', zellij_socket_path_limit: null };
+    }
+    return socketMeta(defaultZellijSocketDir(), 'sks_default');
+}
+export function defaultZellijSocketDir() {
+    const uid = typeof process.getuid === 'function' ? String(process.getuid()) : 'user';
+    return path.join('/tmp', `zj${uid}`);
+}
+export function estimateZellijSocketPathLength(socketDir, sessionName = '') {
+    return path.join(socketDir, 'contract_version_1', sessionName).length;
+}
+export function formatZellijCommand(args = [], meta = resolveZellijProcessEnvMeta()) {
+    const command = ['zellij', ...args].map(shellQuote).join(' ');
+    if (!meta.zellij_socket_dir)
+        return command;
+    return `ZELLIJ_SOCKET_DIR=${shellQuote(meta.zellij_socket_dir)} ${command}`;
+}
+export function isZellijSocketPathTooLong(text) {
+    return /IPC socket path is too long|socket path is too long/i.test(String(text || ''));
+}
 export function parseZellijVersionText(text) {
     const match = String(text || '').match(/\b(\d+\.\d+\.\d+)(?:[-+][0-9A-Za-z.-]+)?\b/);
     return match?.[1] ?? null;
@@ -53,4 +108,20 @@ function versionParts(value) {
     const parsed = parseZellijVersionText(value) || String(value || '0.0.0');
     return parsed.split(/[.-]/).map((part) => Number.parseInt(part, 10) || 0);
 }
+function socketMeta(socketDir, source) {
+    return {
+        zellij_socket_dir: socketDir,
+        zellij_socket_dir_source: source,
+        zellij_socket_path_limit: ZELLIJ_UNIX_SOCKET_PATH_LIMIT
+    };
+}
+function nonEmpty(value) {
+    const text = String(value || '').trim();
+    return text ? text : null;
+}
+function shellQuote(value) {
+    if (/^[A-Za-z0-9_./:=@+-]+$/.test(value))
+        return value;
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
 //# sourceMappingURL=zellij-command.js.map

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

@@ -1,4 +1,5 @@
 export declare const ZELLIJ_SESSION_SCHEMA = "sks.zellij-session.v1";
+export declare const ZELLIJ_SESSION_NAME_MAX = 64;
 export interface ZellijLaunchOptions {
     root?: string;
     missionId?: string;
@@ -25,8 +26,13 @@ export declare function launchZellijLayout(opts?: ZellijLaunchOptions): Promise<
     layout_artifact: string;
     command: string[];
     launch_command: string[];
+    launch_command_with_env: string;
     background_command: string[];
+    background_command_with_env: string;
     attach_command: string;
+    attach_command_with_env: string;
+    zellij_socket_dir: string | null;
+    zellij_socket_dir_source: import("./zellij-command.js").ZellijSocketDirSource;
     pane_proof_path: string;
     pane_proof: {
         schema: string;
@@ -71,8 +77,13 @@ export declare function launchMadZellijUi(args?: readonly unknown[], opts?: Zell
     layout_artifact: string;
     command: string[];
     launch_command: string[];
+    launch_command_with_env: string;
     background_command: string[];
+    background_command_with_env: string;
     attach_command: string;
+    attach_command_with_env: string;
+    zellij_socket_dir: string | null;
+    zellij_socket_dir_source: import("./zellij-command.js").ZellijSocketDirSource;
     pane_proof_path: string;
     pane_proof: {
         schema: string;
@@ -117,8 +128,13 @@ export declare function launchTeamZellijView(opts?: ZellijLaunchOptions): Promis
     layout_artifact: string;
     command: string[];
     launch_command: string[];
+    launch_command_with_env: string;
     background_command: string[];
+    background_command_with_env: string;
     attach_command: string;
+    attach_command_with_env: string;
+    zellij_socket_dir: string | null;
+    zellij_socket_dir_source: import("./zellij-command.js").ZellijSocketDirSource;
     pane_proof_path: string;
     pane_proof: {
         schema: string;

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

@@ -1,10 +1,11 @@
 import path from 'node:path';
-import { appendJsonl, nowIso, writeJsonAtomic } from '../fsx.js';
+import { appendJsonl, nowIso, sha256, writeJsonAtomic } from '../fsx.js';
 import { checkZellijCapability } from './zellij-capability.js';
-import { runZellij } from './zellij-command.js';
+import { formatZellijCommand, resolveZellijProcessEnvMeta, runZellij } from './zellij-command.js';
 import { writeZellijLayout } from './zellij-layout-builder.js';
 import { writeZellijPaneProof } from './zellij-pane-proof.js';
 export const ZELLIJ_SESSION_SCHEMA = 'sks.zellij-session.v1';
+export const ZELLIJ_SESSION_NAME_MAX = 64;
 export async function launchZellijLayout(opts = {}) {
     const root = path.resolve(opts.root || process.cwd());
     const missionId = String(opts.missionId || `M-${Date.now().toString(36)}`);
@@ -24,6 +25,7 @@ export async function launchZellijLayout(opts = {}) {
     const createCommand = ['attach', '--create-background', sessionName, 'options', '--default-layout', layout.layout_path];
     const attachCommand = ['attach', sessionName];
     const command = opts.attach === true ? attachCommand : createCommand;
+    const zellijEnv = resolveZellijProcessEnvMeta();
     const launch = opts.dryRun === true || capability.status !== 'ok'
         ? null
         : opts.attach === true
@@ -65,8 +67,13 @@ export async function launchZellijLayout(opts = {}) {
         layout_artifact: path.relative(root, layout.layout_path),
         command: ['zellij', ...command],
         launch_command: ['zellij', ...createCommand],
+        launch_command_with_env: formatZellijCommand(createCommand, zellijEnv),
         background_command: ['zellij', ...createCommand],
+        background_command_with_env: formatZellijCommand(createCommand, zellijEnv),
         attach_command: `zellij attach ${sessionName}`,
+        attach_command_with_env: formatZellijCommand(attachCommand, zellijEnv),
+        zellij_socket_dir: zellijEnv.zellij_socket_dir,
+        zellij_socket_dir_source: zellijEnv.zellij_socket_dir_source,
         pane_proof_path: path.join(root, '.sneakoscope', 'missions', missionId, 'zellij-pane-proof.json'),
         pane_proof: paneProof,
         dry_run: opts.dryRun === true,
@@ -111,7 +118,13 @@ export async function launchTeamZellijView(opts = {}) {
 }
 export function sanitizeZellijSessionName(value) {
     const cleaned = String(value || 'sks-session').replace(/[^A-Za-z0-9_.:-]+/g, '-').replace(/^-+|-+$/g, '');
-    return cleaned.slice(0, 80) || 'sks-session';
+    if (!cleaned)
+        return 'sks-session';
+    if (cleaned.length <= ZELLIJ_SESSION_NAME_MAX)
+        return cleaned;
+    const suffix = sha256(cleaned).slice(0, 8);
+    const prefix = cleaned.slice(0, ZELLIJ_SESSION_NAME_MAX - suffix.length - 1).replace(/[-_.:]+$/g, '');
+    return `${prefix}-${suffix}`.slice(0, ZELLIJ_SESSION_NAME_MAX);
 }
 function readOption(args, name, fallback) {
     const list = args.map((arg) => String(arg));

package/package.json

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