sneakoscope 1.20.3 → 1.20.5

package/README.md

@@ -16,7 +16,11 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## Current Release
 
-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.
+SKS **1.20.5** makes `sks --mad` actually open the Zellij session. 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.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.
+
+SKS **1.20.3** added the macOS Zellij launch fallback and project-local Fast mode control. SKS 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`.
 

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "1.20.3"
+version = "1.20.5"
 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.3"),
+        Some("--version") => println!("sks-rs 1.20.5"),
         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.3",
-  "source_digest": "c76562a39aaa8ecf01128ce5cda509ad6f8883d1f8c6203c73ddad1d243e54e5",
-  "source_file_count": 1743,
-  "built_at_source_time": 1780267464746
+  "package_version": "1.20.5",
+  "source_digest": "4ba5f14a828460ed0146c7109f59e53e148d6b1ffb42e8c01b00e64086da827e",
+  "source_file_count": 1750,
+  "built_at_source_time": 1780287464818
 }

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '1.20.3';
+const FAST_PACKAGE_VERSION = '1.20.5';
 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.3",
-  "package_version": "1.20.3",
+  "version": "1.20.5",
+  "package_version": "1.20.5",
   "typescript": true,
   "mjs_runtime_files": 0,
-  "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",
+  "compiled_file_count": 1020,
+  "compiled_js_count": 510,
+  "compiled_dts_count": 510,
+  "source_digest": "4ba5f14a828460ed0146c7109f59e53e148d6b1ffb42e8c01b00e64086da827e",
+  "source_file_count": 1750,
+  "source_files_hash": "de93b15a72352d00481b958333ed964bf083563809e3beddfe4e64046720df75",
+  "source_list_hash": "de93b15a72352d00481b958333ed964bf083563809e3beddfe4e64046720df75",
   "src_mjs_runtime_files": 0,
   "dist_stamp_schema": "sks.dist-build-stamp.v1",
   "files": [
@@ -861,6 +861,8 @@
     "core/safety/mutation-ledger.js",
     "core/safety/requested-scope-contract.d.ts",
     "core/safety/requested-scope-contract.js",
+    "core/safety/side-effect-runtime-report.d.ts",
+    "core/safety/side-effect-runtime-report.js",
     "core/secret-redaction.d.ts",
     "core/secret-redaction.js",
     "core/session/project-namespace.d.ts",

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

@@ -4,7 +4,7 @@ import { initProject } from '../init.js';
 import { createMission, setCurrent } from '../mission.js';
 import { enableMadHighProfile, madHighProfileName } from '../auto-review.js';
 import { permissionGateSummary } from '../permission-gates.js';
-import { launchMadZellijUi, sanitizeZellijSessionName } from '../zellij/zellij-launcher.js';
+import { attachZellijSessionInteractive, launchMadZellijUi, sanitizeZellijSessionName } from '../zellij/zellij-launcher.js';
 import { createMadSksAuthorizationManifest, validateMadSksAuthorizationManifest } from '../mad-sks/authorization-manifest.js';
 import { createMadSksAuditLedger, madSksAuditAction, writeMadSksAuditLedger } from '../mad-sks/audit-ledger.js';
 import { compareProtectedCoreSnapshots, evaluateMadSksWrite, resolveProtectedCore, snapshotProtectedCore } from '../mad-sks/immutable-harness-guard.js';
@@ -79,10 +79,48 @@ export async function madHighCommand(args = [], deps = {}) {
     const launchOpts = codexLbImmediateLaunchOpts(cleanArgs, launchLb, { codexArgs: profile.launch_args, conciseBlockers: true, madSksEnv, launchEnv: madSksEnv });
     const workspace = readOption(cleanArgs, '--workspace', readOption(cleanArgs, '--session', launchOpts.session || `sks-mad-${sanitizeZellijSessionName(process.cwd())}`));
     const launch = await launchMadZellijUi([...cleanArgs, '--workspace', workspace], { ...launchOpts, missionId: madLaunch.mission_id, root: madLaunch.root, cwd: process.cwd(), ledgerRoot: path.join(madLaunch.dir, 'agents'), requireZellij: process.env.SKS_REQUIRE_ZELLIJ === '1' });
-    if (!launch.ok)
+    if (!launch.ok) {
         console.log(`MAD Zellij action: ${formatMadZellijAction(launch)}`);
+        return launch;
+    }
+    // The launcher only creates a detached background session. In an interactive
+    // terminal, immediately attach so the session actually opens for the user
+    // 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() });
+        if (!attached.ok) {
+            console.log(`Could not open the Zellij session automatically${attached.error ? ` (${attached.error})` : ''}.`);
+            if (launch.attach_command_with_env)
+                console.log(`Attach with: ${launch.attach_command_with_env}`);
+        }
+        return launch;
+    }
+    if (launch.attach_command_with_env)
+        console.log(`Attach with: ${launch.attach_command_with_env}`);
     return launch;
 }
+// Decide whether to take over the current terminal with a foreground Zellij
+// attach. We only do this for genuinely interactive launches; piped, JSON,
+// non-TTY, or already-inside-Zellij invocations keep the previous behaviour of
+// printing a manual "Attach with:" hint. Use --no-attach (or
+// SKS_NO_ZELLIJ_ATTACH=1) to force the background-only behaviour, and --attach
+// to force attaching even without a detected TTY.
+function shouldAutoAttachZellij(args) {
+    const list = (args || []).map((arg) => String(arg));
+    if (list.includes('--no-attach'))
+        return false;
+    if (list.includes('--json'))
+        return false;
+    if (process.env.SKS_NO_ZELLIJ_ATTACH === '1')
+        return false;
+    // Nested attach is rejected by Zellij when already inside a session.
+    if (process.env.ZELLIJ)
+        return false;
+    if (list.includes('--attach'))
+        return true;
+    return Boolean(process.stdout.isTTY && process.stdin.isTTY);
+}
 function formatMadZellijAction(launch) {
     const blockers = launch.blockers?.join(', ') || launch.warnings?.join(', ') || 'check Zellij installation';
     const details = [
@@ -187,6 +225,8 @@ function madLaunchOnlyFlags() {
         '--MAD',
         '--mad-sks',
         '--high',
+        '--attach',
+        '--no-attach',
         '--no-auto-install-zellij',
         '--allow-system',
         '--allow-db-write',

package/dist/core/fsx.d.ts

@@ -1,4 +1,4 @@
-export declare const PACKAGE_VERSION = "1.20.3";
+export declare const PACKAGE_VERSION = "1.20.5";
 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.3';
+export const PACKAGE_VERSION = '1.20.5';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/release/gate-cache.d.ts

@@ -7,6 +7,11 @@ export interface GateCacheKeyInput {
     inputHashes: string[];
     envMode: string;
     distHash: string;
+    manifestHash?: string;
+    packageScriptsHash?: string;
+    gateImplementationHash?: string;
+    nodeVersion?: string;
+    npmVersion?: string;
 }
 export declare function gateCacheKey(input: GateCacheKeyInput): string;
 export interface GateCacheRecord {

package/dist/core/release/gate-cache.js

@@ -10,7 +10,12 @@ export function gateCacheKey(input) {
         h: input.gitCommit,
         i: [...input.inputHashes].sort(),
         e: input.envMode,
-        d: input.distHash
+        d: input.distHash,
+        m: input.manifestHash || '',
+        s: input.packageScriptsHash || '',
+        gimpl: input.gateImplementationHash || '',
+        node: input.nodeVersion || '',
+        npm: input.npmVersion || ''
     });
     return crypto.createHash('sha256').update(canonical).digest('hex');
 }

package/dist/core/release/gate-manifest.d.ts

@@ -9,7 +9,9 @@ export interface GateManifestEntry {
     always_on_release: boolean;
     required_for_publish: boolean;
     can_run_incremental: boolean;
+    safe_subgate?: string | undefined;
 }
+export declare const FORBIDDEN_RECURSIVE_GATES: Set<string>;
 export declare const ALWAYS_ON_GATES: Set<string>;
 export declare const REQUIRED_FOR_PUBLISH: Set<string>;
 /** Heuristic mapping from a gate id to the source globs that affect it. */

package/dist/core/safety/mutation-guard.d.ts

@@ -16,6 +16,7 @@ export interface GuardOptions {
     confirmed?: boolean;
     backupPath?: string | null;
     noOpReason?: string | null;
+    pathTargets?: string[];
 }
 export declare function guardedWriteFile(ctx: GuardContext, target: string, data: string, opts?: GuardOptions): Promise<void>;
 export declare function guardedGlobalCodexConfigWrite(ctx: GuardContext, target: string, data: string, opts?: GuardOptions): Promise<void>;

package/dist/core/safety/mutation-guard.js

@@ -1,7 +1,7 @@
 import fsp from 'node:fs/promises';
 import path from 'node:path';
 import { runProcess, writeTextAtomic } from '../fsx.js';
-import { isMutationAllowed } from './requested-scope-contract.js';
+import { isMutationAllowed, isPathAllowed } from './requested-scope-contract.js';
 import { evaluateMutation, recordMutation } from './mutation-ledger.js';
 // Mutation Guard Adapter (1.20.2 Area 1a).
 //
@@ -47,6 +47,11 @@ async function guard(ctx, kind, target, opts, apply) {
     const scope = isMutationAllowed(ctx.contract, scopeForKind(kind), { confirmed: opts.confirmed === true });
     if (!scope.allowed)
         throw new MutationGuardViolationError(kind, target, scope.reason);
+    for (const pathTarget of pathTargetsFor(kind, target, opts)) {
+        const pathDecision = isPathAllowed(ctx.contract, pathTarget);
+        if (!pathDecision.allowed)
+            throw new MutationGuardViolationError(kind, pathTarget, pathDecision.reason);
+    }
     if (NEEDS_BACKUP.has(kind) && !opts.backupPath && !opts.noOpReason) {
         throw new MutationGuardViolationError(kind, target, 'backup_or_no_op_reason_required');
     }
@@ -98,6 +103,24 @@ function buildEvalOpts(target, opts, applied) {
         out.noOpReason = opts.noOpReason;
     return out;
 }
+const PATH_SCOPED_KINDS = new Set([
+    'file_write',
+    'file_delete',
+    'file_rename',
+    'chmod',
+    'xattr',
+    'chflags',
+    'global_config_write'
+]);
+function pathTargetsFor(kind, target, opts) {
+    if (!PATH_SCOPED_KINDS.has(kind))
+        return [];
+    if (opts.pathTargets?.length)
+        return opts.pathTargets;
+    if (kind === 'file_rename' && target.includes(' -> '))
+        return target.split(' -> ').map((s) => s.trim()).filter(Boolean);
+    return [target];
+}
 // ---- Public guarded wrappers -------------------------------------------------
 export async function guardedWriteFile(ctx, target, data, opts = {}) {
     await guard(ctx, 'file_write', target, opts, () => writeTextAtomic(target, data));
@@ -109,7 +132,7 @@ export async function guardedRm(ctx, target, opts = {}) {
     await guard(ctx, 'file_delete', target, opts, () => fsp.rm(target, { recursive: opts.recursive === true, force: opts.force !== false }));
 }
 export async function guardedRename(ctx, from, to, opts = {}) {
-    await guard(ctx, 'file_rename', `${from} -> ${to}`, opts, () => fsp.rename(from, to));
+    await guard(ctx, 'file_rename', `${from} -> ${to}`, { ...opts, pathTargets: [from, to] }, () => fsp.rename(from, to));
 }
 export async function guardedChmod(ctx, target, mode, opts = {}) {
     await guard(ctx, 'chmod', target, opts, () => fsp.chmod(target, mode));

package/dist/core/safety/side-effect-runtime-report.d.ts

@@ -0,0 +1,24 @@
+import { type MutationLedgerEntry } from './mutation-ledger.js';
+export declare const SIDE_EFFECT_RUNTIME_REPORT_SCHEMA = "sks.side-effect-runtime-report.v1";
+export interface SideEffectRuntimeReport {
+    schema: string;
+    ok: boolean;
+    generated_at: string;
+    ledger_paths: string[];
+    total_entries: number;
+    applied_entries: number;
+    unexpected_applied_mutations: number;
+    global_mutations_without_confirmation: number;
+    config_mutations_without_backup_or_noop: number;
+    global_mutations: SideEffectRuntimeGlobalMutation[];
+}
+export interface SideEffectRuntimeGlobalMutation {
+    route: string;
+    kind: MutationLedgerEntry['kind'];
+    target: string;
+    backup_path: string | null;
+    no_op_reason: string | null;
+    reason?: string;
+}
+export declare function buildSideEffectRuntimeReport(root: string): Promise<SideEffectRuntimeReport>;
+//# sourceMappingURL=side-effect-runtime-report.d.ts.map

package/dist/core/safety/side-effect-runtime-report.js

@@ -0,0 +1,84 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { mutationLedgerPath } from './mutation-ledger.js';
+export const SIDE_EFFECT_RUNTIME_REPORT_SCHEMA = 'sks.side-effect-runtime-report.v1';
+const GLOBAL_KINDS = new Set(['global_config_write', 'codex_app_flag_change', 'codex_lb_auth_change', 'skill_snapshot_promotion']);
+export async function buildSideEffectRuntimeReport(root) {
+    const ledgerPaths = await discoverLedgerPaths(root);
+    const entries = (await Promise.all(ledgerPaths.map(readLedger))).flat();
+    const applied = entries.filter((entry) => entry.applied === true);
+    const unexpected = applied.filter((entry) => entry.violation === true || entry.requested_scope_allowed !== true);
+    const globalMutations = applied.filter((entry) => GLOBAL_KINDS.has(entry.kind));
+    const globalWithoutConfirmation = globalMutations.filter((entry) => entry.requested_scope_allowed !== true);
+    const configWithoutBackup = globalMutations.filter((entry) => !entry.backup_path && !entry.no_op_reason);
+    return {
+        schema: SIDE_EFFECT_RUNTIME_REPORT_SCHEMA,
+        ok: unexpected.length === 0 && globalWithoutConfirmation.length === 0 && configWithoutBackup.length === 0,
+        generated_at: new Date().toISOString(),
+        ledger_paths: ledgerPaths.map((file) => path.relative(root, file)),
+        total_entries: entries.length,
+        applied_entries: applied.length,
+        unexpected_applied_mutations: unexpected.length,
+        global_mutations_without_confirmation: globalWithoutConfirmation.length,
+        config_mutations_without_backup_or_noop: configWithoutBackup.length,
+        global_mutations: globalMutations.map((entry) => ({
+            route: entry.route,
+            kind: entry.kind,
+            target: entry.target,
+            backup_path: entry.backup_path ?? null,
+            no_op_reason: entry.no_op_reason ?? null,
+            ...(entry.reason ? { reason: entry.reason } : {})
+        }))
+    };
+}
+async function discoverLedgerPaths(root) {
+    const found = new Set();
+    await addIfExists(found, mutationLedgerPath(root));
+    await walkForLedgers(path.join(root, '.sneakoscope', 'missions'), found);
+    return [...found].sort();
+}
+async function walkForLedgers(dir, found) {
+    let entries;
+    try {
+        entries = await fsp.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const file = path.join(dir, entry.name);
+        if (entry.isDirectory())
+            await walkForLedgers(file, found);
+        else if (entry.isFile() && entry.name === 'mutation-ledger.jsonl')
+            found.add(file);
+    }
+}
+async function addIfExists(found, file) {
+    try {
+        await fsp.access(file);
+        found.add(file);
+    }
+    catch { }
+}
+async function readLedger(file) {
+    let text = '';
+    try {
+        text = await fsp.readFile(file, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    return text
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .flatMap((line) => {
+        try {
+            return [JSON.parse(line)];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+//# sourceMappingURL=side-effect-runtime-report.js.map

package/dist/core/skills/core-skill-deployment.d.ts

@@ -5,6 +5,7 @@ export interface PromotionMutationOptions {
     contract?: RequestedScopeContract;
     confirmed?: boolean;
     context?: 'release' | string;
+    ledgerRoot?: string;
 }
 export declare class SkillDeploymentViolationError extends Error {
     constructor(fnName: string);
@@ -19,9 +20,24 @@ export declare function isDeploymentContext(): boolean;
 export declare function assertNotInDeployment(fnName: string): void;
 export declare const readDeploymentSnapshot: typeof loadDeployedSnapshot;
 /**
- * Promote an accepted candidate to an immutable deployed snapshot. The previous
- * snapshot is archived for rollback. Deployed snapshots are never edited in place.
+ * Primary release/deployment promotion API. It writes the immutable deployed
+ * snapshot and treats the side-effect ledger as part of the transaction: when
+ * ledger recording fails, the deployed pointer is rolled back or removed.
  */
+export declare function promoteToDeployedWithLedger(root: string, accepted: CoreSkillCard, opts: PromotionMutationOptions & {
+    contract: RequestedScopeContract;
+}): Promise<{
+    ok: boolean;
+    blockers: string[];
+    snapshot: CoreSkillCard | null;
+    archived_path: string | null;
+}>;
+export declare function promoteToDeployedLegacyForCompatibility(root: string, accepted: CoreSkillCard): Promise<{
+    ok: boolean;
+    blockers: string[];
+    snapshot: CoreSkillCard | null;
+    archived_path: string | null;
+}>;
 export declare function promoteToDeployed(root: string, accepted: CoreSkillCard, opts?: PromotionMutationOptions): Promise<{
     ok: boolean;
     blockers: string[];

package/dist/core/skills/core-skill-deployment.js

@@ -26,10 +26,22 @@ export function assertNotInDeployment(fnName) {
 }
 export const readDeploymentSnapshot = loadDeployedSnapshot;
 /**
- * Promote an accepted candidate to an immutable deployed snapshot. The previous
- * snapshot is archived for rollback. Deployed snapshots are never edited in place.
+ * Primary release/deployment promotion API. It writes the immutable deployed
+ * snapshot and treats the side-effect ledger as part of the transaction: when
+ * ledger recording fails, the deployed pointer is rolled back or removed.
  */
+export async function promoteToDeployedWithLedger(root, accepted, opts) {
+    return promoteToDeployedInternal(root, accepted, opts, true);
+}
+export async function promoteToDeployedLegacyForCompatibility(root, accepted) {
+    return promoteToDeployedInternal(root, accepted, {}, false);
+}
 export async function promoteToDeployed(root, accepted, opts = {}) {
+    if (opts.contract)
+        return promoteToDeployedWithLedger(root, accepted, opts);
+    return promoteToDeployedLegacyForCompatibility(root, accepted);
+}
+async function promoteToDeployedInternal(root, accepted, opts, ledgerRequired) {
     const blockers = [];
     if (accepted.status !== 'accepted')
         blockers.push('promote_requires_accepted_status');
@@ -62,11 +74,11 @@ export async function promoteToDeployed(root, accepted, opts = {}) {
         created_at: nowIso()
     };
     await writeJsonAtomic(deployedPath, snapshot);
-    // Record the promotion as a side-effect-zero ledger entry when a contract is
-    // provided OR a release/deployment-owned context is active. The archived
-    // snapshot is the rollback pointer. Best-effort: a ledger write failure never
-    // breaks promotion semantics (existing 2-arg callers are unaffected).
-    if (opts.contract && (opts.context === 'release' || opts.confirmed || isDeploymentContext())) {
+    if (ledgerRequired) {
+        if (!opts.contract) {
+            await rollbackPromotionWrite(deployedPath, existing);
+            return { ok: false, blockers: ['promotion_ledger_contract_required'], snapshot: null, archived_path: archivedPath };
+        }
         try {
             const entry = evaluateMutation(opts.contract, 'skill_snapshot_promotion', {
                 target: deployedPath,
@@ -75,14 +87,31 @@ export async function promoteToDeployed(root, accepted, opts = {}) {
                 noOpReason: archivedPath ? null : 'first_deploy_no_previous_snapshot',
                 applied: true
             });
-            await recordMutation(root, entry);
+            if (entry.violation) {
+                await rollbackPromotionWrite(deployedPath, existing);
+                return { ok: false, blockers: [`promotion_ledger_violation:${entry.reason || 'unknown'}`], snapshot: null, archived_path: archivedPath };
+            }
+            await recordMutation(opts.ledgerRoot || root, entry);
         }
-        catch {
-            // best-effort ledger recording; promotion already succeeded.
+        catch (err) {
+            await rollbackPromotionWrite(deployedPath, existing);
+            const message = err instanceof Error ? err.message : String(err);
+            return { ok: false, blockers: [`promotion_ledger_write_failed:${message}`], snapshot: null, archived_path: archivedPath };
         }
     }
     return { ok: true, blockers: [], snapshot, archived_path: archivedPath };
 }
+async function rollbackPromotionWrite(deployedPath, existing) {
+    if (existing)
+        await writeJsonAtomic(deployedPath, existing);
+    else {
+        try {
+            const fsp = await import('node:fs/promises');
+            await fsp.rm(deployedPath, { force: true });
+        }
+        catch { }
+    }
+}
 export async function rollbackDeployment(root, route, skillId) {
     const dir = skillDir(root, route, skillId);
     const historyDir = path.join(dir, 'deployed-history');

package/dist/core/version.d.ts

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

package/dist/core/version.js

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

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

@@ -165,5 +165,25 @@ export declare function launchTeamZellijView(opts?: ZellijLaunchOptions): Promis
     blockers: any[];
     warnings: string[];
 }>;
+export interface ZellijAttachResult {
+    ok: boolean;
+    status: number | null;
+    signal: NodeJS.Signals | null;
+    error?: string;
+}
+/**
+ * Attach the current terminal to an existing Zellij session in the foreground.
+ *
+ * `launchZellijLayout` only ever *creates* a detached background session, which
+ * is correct for proof/automation but means an interactive launch (e.g.
+ * `sks --mad`) never actually opens anything. This helper performs the
+ * follow-up foreground attach, inheriting stdio so the session takes over the
+ * user's terminal until they detach. It is a no-op-style failure (never throws)
+ * when Zellij is missing or attach fails, so callers can fall back to printing a
+ * manual attach hint.
+ */
+export declare function attachZellijSessionInteractive(sessionName: string, opts?: {
+    cwd?: string;
+}): ZellijAttachResult;
 export declare function sanitizeZellijSessionName(value: unknown): string;
 //# sourceMappingURL=zellij-launcher.d.ts.map

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

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { spawnSync } from 'node:child_process';
 import { appendJsonl, nowIso, sha256, writeJsonAtomic } from '../fsx.js';
 import { checkZellijCapability } from './zellij-capability.js';
 import { formatZellijCommand, resolveZellijProcessEnvMeta, runZellij } from './zellij-command.js';
@@ -116,6 +117,38 @@ export async function launchTeamZellijView(opts = {}) {
         slotCount: opts.slotCount || 5
     });
 }
+/**
+ * Attach the current terminal to an existing Zellij session in the foreground.
+ *
+ * `launchZellijLayout` only ever *creates* a detached background session, which
+ * is correct for proof/automation but means an interactive launch (e.g.
+ * `sks --mad`) never actually opens anything. This helper performs the
+ * follow-up foreground attach, inheriting stdio so the session takes over the
+ * user's terminal until they detach. It is a no-op-style failure (never throws)
+ * when Zellij is missing or attach fails, so callers can fall back to printing a
+ * manual attach hint.
+ */
+export function attachZellijSessionInteractive(sessionName, opts = {}) {
+    if (!sessionName)
+        return { ok: false, status: null, signal: null, error: 'missing_session_name' };
+    const meta = resolveZellijProcessEnvMeta();
+    const env = { ...process.env };
+    if (meta.zellij_socket_dir && !env.ZELLIJ_SOCKET_DIR)
+        env.ZELLIJ_SOCKET_DIR = meta.zellij_socket_dir;
+    try {
+        const result = spawnSync('zellij', ['attach', sessionName], {
+            cwd: opts.cwd || process.cwd(),
+            env,
+            stdio: 'inherit'
+        });
+        if (result.error)
+            return { ok: false, status: null, signal: null, error: result.error.message };
+        return { ok: result.status === 0, status: result.status ?? null, signal: result.signal ?? null };
+    }
+    catch (err) {
+        return { ok: false, status: null, signal: null, error: err?.message || String(err) };
+    }
+}
 export function sanitizeZellijSessionName(value) {
     const cleaned = String(value || 'sks-session').replace(/[^A-Za-z0-9_.:-]+/g, '-').replace(/^-+|-+$/g, '');
     if (!cleaned)

package/dist/scripts/release-parallel-check.js

@@ -113,10 +113,16 @@ const tasks = [
     task('core-skill:no-inference-optimizer', 'npm run core-skill:no-inference-optimizer --silent', { dependencies: ['build'] }),
     task('core-skill:route-runtime-integration', 'npm run core-skill:route-runtime-integration --silent', { dependencies: ['build'] }),
     task('core-skill:promotion-side-effect-ledger', 'npm run core-skill:promotion-side-effect-ledger --silent', { dependencies: ['build'] }),
+    task('core-skill:legacy-promotion-api-audit', 'npm run core-skill:legacy-promotion-api-audit --silent', { dependencies: ['build'] }),
     task('safety:side-effect-zero', 'npm run safety:side-effect-zero --silent', { dependencies: ['build'] }),
     task('safety:mutation-callsite-coverage', 'npm run safety:mutation-callsite-coverage --silent', { dependencies: ['build'] }),
+    task('safety:mutation-callsite-coverage:repo-wide', 'npm run safety:mutation-callsite-coverage:repo-wide --silent', { dependencies: ['build'] }),
+    task('side-effect:runtime-report', 'npm run side-effect:runtime-report --silent', { dependencies: ['build'] }),
     task('zellij:doctor-readiness', 'npm run zellij:doctor-readiness --silent', { dependencies: ['build'] }),
+    task('release:version-truth', 'npm run release:version-truth --silent', { dependencies: ['build'] }),
     task('release:gate-planner', 'npm run release:gate-planner --silent', { dependencies: ['build'] }),
+    task('release:dynamic-performance', 'npm run release:dynamic-performance --silent', { dependencies: ['release:gate-planner'] }),
+    task('release:provenance', 'npm run release:provenance --silent', { dependencies: ['build', 'release:version-truth'] }),
     task('release:gate-budget', 'npm run release:gate-budget --silent', { dependencies: ['build'] }),
     task('agent:wiki-context-proof', 'npm run agent:wiki-context-proof --silent', { dependencies: ['build'] }),
     task('shared-memory:check', 'npm run shared-memory:check --silent', { dependencies: ['build'] }),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "1.20.3",
+  "version": "1.20.5",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -81,11 +81,16 @@
     "core-skill:no-inference-optimizer": "node ./scripts/core-skill-no-inference-optimizer-check.mjs",
     "core-skill:route-runtime-integration": "node ./scripts/core-skill-route-runtime-integration-check.mjs",
     "core-skill:promotion-side-effect-ledger": "node ./scripts/core-skill-promotion-side-effect-ledger-check.mjs",
+    "core-skill:legacy-promotion-api-audit": "node ./scripts/core-skill-legacy-promotion-api-audit.mjs",
     "safety:side-effect-zero": "node ./scripts/side-effect-zero-gate-check.mjs",
     "safety:mutation-callsite-coverage": "node ./scripts/mutation-callsite-coverage-check.mjs",
+    "safety:mutation-callsite-coverage:repo-wide": "node ./scripts/mutation-callsite-coverage-check.mjs --repo-wide",
+    "side-effect:runtime-report": "node ./scripts/side-effect-runtime-report-check.mjs",
     "release:gate-planner": "node ./scripts/release-gate-planner.mjs",
     "release:check:dynamic": "node ./scripts/release-check-dynamic.mjs",
     "release:check:dynamic:execute": "node ./scripts/release-check-dynamic-execute.mjs",
+    "release:dynamic-performance": "node ./scripts/release-dynamic-performance-check.mjs",
+    "release:provenance": "node ./scripts/release-provenance-check.mjs",
     "release:gate-budget": "node ./scripts/release-gate-budget-check.mjs",
     "agent:wiki-context-proof": "node ./scripts/agent-wiki-context-proof-check.mjs",
     "prepublish:fast-check": "node ./scripts/prepublish-fast-check.mjs",
@@ -232,18 +237,19 @@
     "computer-use:live-optional": "node ./scripts/computer-use-live-optional-check.mjs",
     "computer-use:live-evidence": "node ./scripts/computer-use-live-evidence-check.mjs",
     "docs:truthfulness": "node ./scripts/docs-truthfulness-check.mjs",
-    "release:metadata": "node ./scripts/release-metadata-1-19-check.mjs",
+    "release:metadata": "node ./scripts/release-metadata-check.mjs",
+    "release:version-truth": "node ./scripts/release-version-truth-check.mjs",
     "release:gate-existence-audit": "node ./scripts/release-gate-existence-audit.mjs",
     "release:native-agent-backend": "node ./scripts/release-native-agent-fixture-check.mjs",
     "release:readiness": "node ./scripts/release-readiness-report.mjs",
     "coverage": "node --experimental-test-coverage --test \"test/**/*.test.mjs\"",
-    "release:check": "npm run release:check:parallel && npm run codex:0.135-compat && npm run doctor:codex-doctor-parity && npm run codex:permission-profiles && npm run codex:legacy-profile-consumers-removed && npm run terminal:keyboard-enhancement-safety && npm run terminal:tui-output-stability && npm run codex:resume-cwd-truth && npm run mcp:tool-naming-parity && npm run responses:retry-policy-centralized && npm run runtime:no-tmux && npm run zellij:layout-valid && npm run zellij:lane-renderer && npm run mad-sks:zellij-launch && npm run agent:zellij-runtime && npm run codex:config-eperm-fixture && npm run doctor:fix-proves-codex-read && npm run mad:preflight-blocks-unreadable-config && npm run fast:codex-service-tier-proof && npm run codex:project-config-policy-splitter && npm run test:no-orphan-dist-imports && npm run agent:patch-envelope-extraction && npm run agent:patch-queue-runtime && npm run agent:strategy-to-lease-wiring && npm run agent:patch-swarm-runtime && npm run agent:patch-transaction-journal && npm run agent:patch-conflict-rebase && npm run agent:strategy-to-patch-strict && npm run agent:patch-swarm-runtime-truth && npm run agent:rollback-command && npm run agent:patch-verification-dag && npm run agent:patch-rollback-dag && npm run agent:patch-proof-runtime && npm run agent:patch-swarm-route-blackbox && npm run team:patch-swarm-route-blackbox && npm run dfix:patch-swarm-route-blackbox && npm run appshots:thread-attachment-discovery && npm run mcp:readonly-runtime-scheduler && npm run codex:0.134-runner-truth && npm run agent:native-cli-session-swarm && npm run agent:native-cli-session-swarm-10 && npm run agent:native-cli-session-swarm-20 && npm run agent:no-subagent-scaling && npm run agent:native-cli-session-proof && npm run agent:worker-backend-router && npm run agent:codex-child-overlap && npm run agent:model-authored-patch-envelope && npm run agent:fast-mode-default && npm run agent:fast-mode-worker-propagation && npm run codex:fast-mode-profile-propagation && npm run mad-sks:fast-mode-propagation && npm run zellij:launch-command-truth && npm run zellij:real-session-heartbeat && npm run zellij:ui-design && npm run zellij:doctor-readiness && npm run legacy:upgrade-zero-break && npm run publish:packlist-performance && npm run postinstall:safe-side-effects && npm run runtime:ts-rust-boundary && npm run core-skill:card-schema && npm run core-skill:rollout-scoring && npm run core-skill:patch && npm run core-skill:heldout-validation && npm run core-skill:deployment-snapshot && npm run core-skill:no-inference-optimizer && npm run core-skill:route-runtime-integration && npm run core-skill:promotion-side-effect-ledger && npm run safety:side-effect-zero && npm run safety:mutation-callsite-coverage && npm run release:gate-planner && npm run release:gate-budget && npm run agent:wiki-context-proof && npm run shared-memory:check && npm run wrongness:check && npm run wrongness:fixtures && npm run trust:check && npm run git-collaboration:e2e && node ./scripts/release-check-stamp.mjs write && npm run release:readiness --silent && node ./scripts/release-check-stamp.mjs write",
+    "release:check": "npm run release:check:parallel && npm run release:version-truth && npm run codex:0.135-compat && npm run doctor:codex-doctor-parity && npm run codex:permission-profiles && npm run codex:legacy-profile-consumers-removed && npm run terminal:keyboard-enhancement-safety && npm run terminal:tui-output-stability && npm run codex:resume-cwd-truth && npm run mcp:tool-naming-parity && npm run responses:retry-policy-centralized && npm run runtime:no-tmux && npm run zellij:layout-valid && npm run zellij:lane-renderer && npm run mad-sks:zellij-launch && npm run agent:zellij-runtime && npm run codex:config-eperm-fixture && npm run doctor:fix-proves-codex-read && npm run mad:preflight-blocks-unreadable-config && npm run fast:codex-service-tier-proof && npm run codex:project-config-policy-splitter && npm run test:no-orphan-dist-imports && npm run agent:patch-envelope-extraction && npm run agent:patch-queue-runtime && npm run agent:strategy-to-lease-wiring && npm run agent:patch-swarm-runtime && npm run agent:patch-transaction-journal && npm run agent:patch-conflict-rebase && npm run agent:strategy-to-patch-strict && npm run agent:patch-swarm-runtime-truth && npm run agent:rollback-command && npm run agent:patch-verification-dag && npm run agent:patch-rollback-dag && npm run agent:patch-proof-runtime && npm run agent:patch-swarm-route-blackbox && npm run team:patch-swarm-route-blackbox && npm run dfix:patch-swarm-route-blackbox && npm run appshots:thread-attachment-discovery && npm run mcp:readonly-runtime-scheduler && npm run codex:0.134-runner-truth && npm run agent:native-cli-session-swarm && npm run agent:native-cli-session-swarm-10 && npm run agent:native-cli-session-swarm-20 && npm run agent:no-subagent-scaling && npm run agent:native-cli-session-proof && npm run agent:worker-backend-router && npm run agent:codex-child-overlap && npm run agent:model-authored-patch-envelope && npm run agent:fast-mode-default && npm run agent:fast-mode-worker-propagation && npm run codex:fast-mode-profile-propagation && npm run mad-sks:fast-mode-propagation && npm run zellij:launch-command-truth && npm run zellij:real-session-heartbeat && npm run zellij:ui-design && npm run zellij:doctor-readiness && npm run legacy:upgrade-zero-break && npm run publish:packlist-performance && npm run postinstall:safe-side-effects && npm run runtime:ts-rust-boundary && npm run core-skill:card-schema && npm run core-skill:rollout-scoring && npm run core-skill:patch && npm run core-skill:heldout-validation && npm run core-skill:deployment-snapshot && npm run core-skill:no-inference-optimizer && npm run core-skill:route-runtime-integration && npm run core-skill:promotion-side-effect-ledger && npm run core-skill:legacy-promotion-api-audit && npm run safety:side-effect-zero && npm run safety:mutation-callsite-coverage && npm run safety:mutation-callsite-coverage:repo-wide && npm run side-effect:runtime-report && npm run release:gate-planner && npm run release:dynamic-performance && npm run release:provenance && npm run release:gate-budget && npm run agent:wiki-context-proof && npm run shared-memory:check && npm run wrongness:check && npm run wrongness:fixtures && npm run trust:check && npm run git-collaboration:e2e && node ./scripts/release-check-stamp.mjs write && npm run release:readiness --silent && node ./scripts/release-check-stamp.mjs write",
     "release:real-check": "node ./scripts/release-real-check.mjs",
     "release:publish": "npm run publish:npm",
-    "publish:dry": "npm run release:metadata && node ./scripts/release-check-stamp.mjs ensure && npm run release:dist-freshness && npm --cache /tmp/sks-npm-cache publish --dry-run --registry https://registry.npmjs.org/ --access public",
+    "publish:dry": "npm run release:metadata && npm run release:version-truth && npm run publish:packlist-performance && npm run prepublish:fast-check && node ./scripts/release-check-stamp.mjs verify && npm run release:provenance -- --publish && npm run release:dist-freshness && npm --cache /tmp/sks-npm-cache publish --dry-run --registry https://registry.npmjs.org/ --access public",
     "publish:npm": "npm --cache /tmp/sks-npm-cache publish --registry https://registry.npmjs.org/ --access public",
     "prepack": "npm run build",
-    "prepublishOnly": "npm run release:metadata && npm run release:dist-freshness && npm run publish:packlist-performance && node ./scripts/check-publish-tag.mjs && node ./scripts/release-check-stamp.mjs ensure && node ./scripts/release-registry-check.mjs --require-unpublished",
+    "prepublishOnly": "npm run release:metadata && npm run release:version-truth && npm run release:dist-freshness && npm run publish:packlist-performance && npm run prepublish:fast-check && node ./scripts/check-publish-tag.mjs && node ./scripts/release-check-stamp.mjs verify && npm run release:provenance -- --publish && node ./scripts/release-registry-check.mjs --require-unpublished",
     "dist:check": "node ./scripts/check-dist-runtime.mjs",
     "ux-review:run-wires-imagegen": "node ./scripts/ux-review-run-wires-imagegen-check.mjs",
     "ux-review:extract-wires-real-extractor": "node ./scripts/ux-review-extract-wires-real-extractor-check.mjs",