sneakoscope 6.0.3 → 6.1.2

package/dist/scripts/zellij-layout-valid-check.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 // @ts-nocheck
 import fs from 'node:fs/promises';
+import { randomBytes } from 'node:crypto';
 import os from 'node:os';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
@@ -11,18 +12,18 @@ if (!freshness.ok)
 const layoutMod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-layout-builder.js')).href);
 const capabilityMod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-capability.js')).href);
 const commandMod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-command.js')).href);
-process.env.SKS_ZELLIJ_VIEWPORTS = '4';
+process.env.SKS_ZELLIJ_VIEWPORTS = '3';
 const built = layoutMod.buildZellijLayoutKdl({ missionId: 'M-layout-check', ledgerRoot: path.join(root, '.sneakoscope', 'tmp', 'layout-check'), cwd: root, kind: 'mad', slotCount: 2, codexArgs: ['--profile', 'sks-mad-high', '-c', 'service_tier=fast'] });
 const staticValidation = layoutMod.validateZellijLayoutKdl(built.layout_kdl);
 const viewportLayoutOk = built.initial_worker_panes === 0
-    && built.viewport_count === 4
+    && built.viewport_count === 3
     && built.ui_architecture === 'monitor_plus_viewports'
     && built.lane_runtime_policies.length === 0
     && built.layout_kdl.includes('pane name="orchestrator"')
     && built.layout_kdl.includes('pane size="35%" name="sks-monitor"')
     && !built.layout_kdl.includes('zellij-lane')
     && !built.layout_kdl.includes('zellij-slot-pane')
-    && (built.layout_kdl.match(/pane name="sks-viewport-/g) || []).length === 4
+    && (built.layout_kdl.match(/pane name="sks-viewport-/g) || []).length === 3
     && built.lane_dispatch_policy?.mode === 'jsonl_nonblocking'
     && built.lane_dispatch_policy?.fifo_policy === 'disabled_to_avoid_writer_blocking'
     && built.lane_dispatch_policy?.pane_transport === 'monitor_plus_viewports';
@@ -46,7 +47,7 @@ const kindsValidated = ['mad', 'agent', 'team', 'naruto'].map((kind) => {
     const hasCodexPane = kind !== 'mad' || (b.main_pane_kind === 'codex_interactive' && /exec\s+'?codex'?/.test(b.layout_kdl) && b.layout_kdl.includes('sks-mad-high') && b.layout_kdl.includes('--no-alt-screen'));
     const viewportPaneCount = (b.layout_kdl.match(/pane name="sks-viewport-/g) || []).length;
     const noLanePane = !b.layout_kdl.includes('zellij-lane');
-    return { kind, ok: layoutMod.validateZellijLayoutKdl(b.layout_kdl).ok && hasCodexPane && noLanePane && viewportPaneCount === 4 && b.initial_worker_panes === 0 && b.viewport_count === 4, main_pane_kind: b.main_pane_kind, has_codex_pane: hasCodexPane, no_lane_pane: noLanePane, viewport_pane_count: viewportPaneCount };
+    return { kind, ok: layoutMod.validateZellijLayoutKdl(b.layout_kdl).ok && hasCodexPane && noLanePane && viewportPaneCount === 3 && b.initial_worker_panes === 0 && b.viewport_count === 3, main_pane_kind: b.main_pane_kind, has_codex_pane: hasCodexPane, no_lane_pane: noLanePane, viewport_pane_count: viewportPaneCount };
 });
 const allKindsOk = kindsValidated.every((k) => k.ok);
 const invalidValidation = layoutMod.validateZellijLayoutKdl('layout { pane command="zellij-lane" {');
@@ -55,28 +56,37 @@ const layoutPath = path.join(tmp, 'layout.kdl');
 await fs.writeFile(layoutPath, built.layout_kdl, 'utf8');
 const requireReal = process.env.SKS_REQUIRE_ZELLIJ === '1' || process.argv.includes('--require-real');
 const capability = await capabilityMod.checkZellijCapability({ root, require: requireReal, writeReport: true });
-const sessionName = 'sks-layout-check';
-if (capability.status === 'ok')
-    await commandMod.runZellij(['kill-session', sessionName], { cwd: root, timeoutMs: 2500, optional: true });
+const runId = `${process.pid}-${Date.now().toString(36)}-${randomBytes(3).toString('hex')}`;
+const sessionName = `sks-layout-check-${runId}`;
+const socketDir = path.join('/tmp', `sks-zj-layout-${runId}`);
+const zellijEnv = { ZELLIJ_SOCKET_DIR: socketDir };
 const realRun = capability.status === 'ok'
     ? {
-        create_background: await commandMod.runZellij(['attach', '--create-background', sessionName, 'options', '--default-layout', layoutPath], { cwd: root, timeoutMs: 5000, optional: !requireReal }),
+        create_background: await commandMod.runZellij(['attach', '--create-background', sessionName, 'options', '--default-layout', layoutPath], { cwd: root, env: zellijEnv, timeoutMs: 5000, optional: !requireReal }),
         cleanup: null,
+        session_removed: false,
+        socket_dir_removed: false,
         ok: false
     }
     : null;
 if (realRun) {
-    realRun.cleanup = await commandMod.runZellij(['kill-session', sessionName], { cwd: root, timeoutMs: 5000, optional: true });
-    realRun.ok = realRun.create_background.ok === true;
+    realRun.cleanup = await commandMod.runZellij(['kill-session', sessionName], { cwd: root, env: zellijEnv, timeoutMs: 5000, optional: true });
+    const remaining = await waitForSocketEntriesToClear(socketDir, 2000);
+    realRun.session_removed = !remaining.includes(sessionName);
+    if (remaining.length === 0)
+        await fs.rm(socketDir, { recursive: true, force: true });
+    realRun.socket_dir_removed = !(await exists(socketDir));
+    realRun.ok = realRun.create_background.ok === true && realRun.session_removed && realRun.socket_dir_removed;
 }
 const ok = staticValidation.ok
     && viewportLayoutOk
     && allKindsOk
     && layoutMod.validateZellijLayoutKdl(narutoFanoutLayout.layout_kdl).ok
-    && narutoFanoutPaneCount === 4
+    && narutoFanoutPaneCount === 3
     && invalidValidation.ok === false
     && capability.ok
     && (requireReal ? realRun?.ok === true : true);
+await fs.rm(tmp, { recursive: true, force: true });
 emit({
     schema: 'sks.zellij-layout-valid-check.v1',
     ok,
@@ -88,10 +98,25 @@ emit({
     invalid_fixture: invalidValidation,
     capability,
     real_run: realRun,
+    isolated_session: true,
+    socket_dir: socketDir,
+    temporary_layout_removed: !(await exists(tmp)),
     integration_optional: !requireReal,
     blockers: ok ? [] : ['zellij_layout_valid_check_failed']
 });
 function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
     process.exitCode = 1; }
 function fail(blocker, detail) { emit({ schema: 'sks.zellij-layout-valid-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
+async function waitForSocketEntriesToClear(socketDir, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        const entries = await fs.readdir(path.join(socketDir, 'contract_version_1')).catch(() => []);
+        if (entries.length === 0 || Date.now() >= deadline)
+            return entries;
+        await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+}
+async function exists(value) {
+    return fs.access(value).then(() => true).catch(() => false);
+}
 //# sourceMappingURL=zellij-layout-valid-check.js.map

package/dist/scripts/zellij-pane-proof-check.js

@@ -42,13 +42,44 @@ const codexLbOnlyMain = mod.evaluateZellijPaneProofRows(mod.normalizeZellijPaneR
     { pane_id: '1', name: 'orchestrator', command: 'sh -lc model_provider="codex-lb"', cwd: root, exited: false },
     { pane_id: '2', name: 'slot-001', command: 'sks zellij-lane --mission M --slot slot-001', cwd: root, exited: false }
 ]), { expectedLaneCount: 1, expectedCwd: root, expectedMainCommandIncludes: 'codex' });
+const zellij044Rows = [
+    ...Array.from({ length: 120 }, (_, index) => ({
+        id: index + 10,
+        is_plugin: true,
+        title: `zellij:fixture-${String(index).padStart(3, '0')}`,
+        terminal_command: null,
+        plugin_url: 'zellij:fixture',
+        tab_name: 'SKS fixture'
+    })),
+    {
+        id: 0,
+        is_plugin: false,
+        title: 'orchestrator',
+        exited: false,
+        exit_status: null,
+        pane_x: 0,
+        pane_y: 1,
+        pane_columns: 80,
+        pane_rows: 24,
+        terminal_command: "sh -lc exec 'codex' '--no-alt-screen'",
+        pane_command: `${path.join(root, 'node_modules', '.bin', 'codex')} --no-alt-screen`,
+        pane_cwd: root,
+        tab_name: 'SKS fixture'
+    }
+];
+const zellij044Json = JSON.stringify(zellij044Rows);
+const zellij044Parsed = mod.parseZellijPaneRows(zellij044Json);
+const zellij044Evaluation = mod.evaluateZellijPaneProofRows(mod.normalizeZellijPaneRows(zellij044Parsed), { expectedLaneCount: 0, expectedCwd: root, expectedMainCommandIncludes: 'codex' });
 const fixtureOk = positive.blockers.length === 0
     && missingLane.blockers.includes('zellij_lane_pane_missing')
     && exitedLane.blockers.some((blocker) => blocker.startsWith('zellij_lane_pane_exited'))
     && madCodexMain.blockers.length === 0
     && madShellMain.blockers.includes('zellij_main_pane_unexpected_command:codex')
-    && codexLbOnlyMain.blockers.includes('zellij_main_pane_unexpected_command:codex');
-emit({ ...report, fixture_ok: fixtureOk, fixture_results: { positive, missingLane, exitedLane, madCodexMain, madShellMain, codexLbOnlyMain }, ok: report.ok && fixtureOk });
+    && codexLbOnlyMain.blockers.includes('zellij_main_pane_unexpected_command:codex')
+    && zellij044Json.length > 8192
+    && zellij044Parsed.length === zellij044Rows.length
+    && zellij044Evaluation.blockers.length === 0;
+emit({ ...report, fixture_ok: fixtureOk, fixture_results: { positive, missingLane, exitedLane, madCodexMain, madShellMain, codexLbOnlyMain, zellij044: { json_bytes: Buffer.byteLength(zellij044Json), parsed_rows: zellij044Parsed.length, evaluation: zellij044Evaluation } }, ok: report.ok && fixtureOk });
 function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
     process.exitCode = 1; }
 function fail(blocker, detail) { emit({ schema: 'sks.zellij-pane-proof-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }

package/dist/scripts/zellij-real-session-cleanup-check.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 // @ts-nocheck
+import fs from 'node:fs/promises';
+import { createHash } from 'node:crypto';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
@@ -7,10 +9,96 @@ const freshness = ensureDistFresh({ rebuild: false });
 if (!freshness.ok)
     fail('dist_not_fresh', { freshness });
 const args = process.argv.slice(2);
+const missionId = readArg(args, '--mission');
 const sessionName = readArg(args, '--session') || 'sks-real';
+const socketDir = readArg(args, '--owned-socket-dir');
+const ownerToken = String(process.env.SKS_ZELLIJ_CHECK_OWNER_TOKEN || '');
 const command = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-command.js')).href);
-const result = await command.runZellij(['kill-session', sessionName], { cwd: root, timeoutMs: 5000, optional: true });
-emit({ schema: 'sks.zellij-real-session-cleanup-check.v1', ok: result.ok === true || result.exit_code !== 0, session_name: sessionName, result });
+const ownershipPath = missionId ? path.join(root, '.sneakoscope', 'missions', missionId, 'zellij-real-session-ownership.json') : null;
+const expectedLayoutPath = missionId ? path.join(root, '.sneakoscope', 'layouts', `mad-${missionId}.kdl`) : null;
+const ownership = ownershipPath ? await readJson(ownershipPath) : null;
+const ownershipBlockers = [
+    ...(!missionId ? ['zellij_cleanup_mission_missing'] : []),
+    ...(!isSafeOwnedSocketDir(socketDir) ? ['zellij_cleanup_owned_socket_dir_invalid'] : []),
+    ...(ownerToken.length < 32 ? ['zellij_cleanup_owner_token_missing'] : []),
+    ...(!ownership ? ['zellij_cleanup_ownership_marker_missing'] : []),
+    ...(ownership && ownership.schema !== 'sks.zellij-real-session-ownership.v1' ? ['zellij_cleanup_ownership_schema_invalid'] : []),
+    ...(ownership && ownership.mission_id !== missionId ? ['zellij_cleanup_mission_mismatch'] : []),
+    ...(ownership && ownership.session_name !== sessionName ? ['zellij_cleanup_session_mismatch'] : []),
+    ...(ownership && path.resolve(String(ownership.socket_dir || '')) !== path.resolve(String(socketDir || '')) ? ['zellij_cleanup_socket_dir_mismatch'] : []),
+    ...(ownership && ownership.owner_token_sha256 !== hashOwnerToken(ownerToken) ? ['zellij_cleanup_owner_token_mismatch'] : []),
+    ...(ownership && ownership.cleanup_authorized !== true ? ['zellij_cleanup_not_authorized'] : []),
+    ...(ownership && ownership.layout_cleanup_authorized !== true ? ['zellij_cleanup_layout_not_authorized'] : []),
+    ...(ownership && path.resolve(String(ownership.layout_path || '')) !== path.resolve(String(expectedLayoutPath || '')) ? ['zellij_cleanup_layout_path_mismatch'] : [])
+];
+if (ownershipBlockers.length > 0) {
+    emit({
+        schema: 'sks.zellij-real-session-cleanup-check.v1',
+        ok: false,
+        mutation_attempted: false,
+        mission_id: missionId,
+        session_name: sessionName,
+        socket_dir: socketDir,
+        ownership_path: ownershipPath,
+        blockers: ownershipBlockers
+    });
+}
+else {
+    const beforeEntries = await socketEntries(socketDir);
+    const result = await command.runZellij(['kill-session', sessionName], {
+        cwd: root,
+        env: { ZELLIJ_SOCKET_DIR: socketDir },
+        timeoutMs: 5000,
+        optional: true
+    });
+    const remainingEntries = await waitForSocketEntriesToClear(socketDir, 2000);
+    const sessionRemoved = !remainingEntries.includes(sessionName);
+    const socketExclusive = remainingEntries.length === 0;
+    const layoutPresentBefore = await exists(expectedLayoutPath);
+    const layoutSha256Before = layoutPresentBefore ? await sha256File(expectedLayoutPath) : null;
+    const layoutHashMatches = !layoutPresentBefore || !ownership.layout_sha256 || layoutSha256Before === ownership.layout_sha256;
+    let socketDirRemoved = false;
+    let layoutRemoved = false;
+    if (sessionRemoved && socketExclusive) {
+        await fs.rm(socketDir, { recursive: true, force: true });
+        socketDirRemoved = !(await exists(socketDir));
+        if (socketDirRemoved && layoutHashMatches) {
+            await fs.rm(expectedLayoutPath, { force: true });
+            layoutRemoved = !(await exists(expectedLayoutPath));
+        }
+    }
+    const blockers = [
+        ...(!sessionRemoved ? ['zellij_cleanup_session_still_present'] : []),
+        ...(!socketExclusive ? ['zellij_cleanup_owned_socket_dir_not_empty'] : []),
+        ...(!socketDirRemoved ? ['zellij_cleanup_socket_dir_not_removed'] : []),
+        ...(!layoutHashMatches ? ['zellij_cleanup_layout_hash_mismatch'] : []),
+        ...(!layoutRemoved ? ['zellij_cleanup_layout_not_removed'] : [])
+    ];
+    const report = {
+        schema: 'sks.zellij-real-session-cleanup-check.v1',
+        ok: blockers.length === 0,
+        mutation_attempted: true,
+        mission_id: missionId,
+        session_name: sessionName,
+        socket_dir: socketDir,
+        ownership_path: ownershipPath,
+        session_present_before: beforeEntries.includes(sessionName),
+        session_removed: sessionRemoved,
+        socket_dir_exclusive: socketExclusive,
+        socket_dir_removed: socketDirRemoved,
+        layout_path: expectedLayoutPath,
+        layout_sha256: ownership.layout_sha256 || null,
+        layout_sha256_before_cleanup: layoutSha256Before,
+        layout_hash_matches: layoutHashMatches,
+        layout_removed: layoutRemoved,
+        remaining_socket_entries: remainingEntries,
+        result,
+        blockers,
+        warnings: result.ok ? [] : ['zellij_kill_session_nonzero_but_absence_verified']
+    };
+    await fs.writeFile(path.join(root, '.sneakoscope', 'missions', missionId, 'zellij-real-session-cleanup.json'), `${JSON.stringify(report, null, 2)}\n`);
+    emit(report);
+}
 function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
     process.exitCode = 1; }
 function fail(blocker, detail) { emit({ schema: 'sks.zellij-real-session-cleanup-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
@@ -18,4 +106,36 @@ function readArg(args, name) {
     const index = args.indexOf(name);
     return index >= 0 ? args[index + 1] || null : null;
 }
+function hashOwnerToken(value) {
+    return createHash('sha256').update(String(value)).digest('hex');
+}
+async function sha256File(file) {
+    return fs.readFile(file).then((data) => createHash('sha256').update(data).digest('hex')).catch(() => null);
+}
+function isSafeOwnedSocketDir(value) {
+    if (!value)
+        return false;
+    const resolved = path.resolve(String(value));
+    return path.dirname(resolved) === '/tmp' && /^sks-zj-rr-[A-Za-z0-9-]+$/.test(path.basename(resolved));
+}
+async function readJson(file) {
+    return fs.readFile(file, 'utf8').then((text) => JSON.parse(text)).catch(() => null);
+}
+async function socketEntries(socketDir) {
+    if (!socketDir)
+        return [];
+    return fs.readdir(path.join(socketDir, 'contract_version_1')).catch(() => []);
+}
+async function waitForSocketEntriesToClear(socketDir, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        const entries = await socketEntries(socketDir);
+        if (entries.length === 0 || Date.now() >= deadline)
+            return entries;
+        await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+}
+async function exists(value) {
+    return fs.access(value).then(() => true).catch(() => false);
+}
 //# sourceMappingURL=zellij-real-session-cleanup-check.js.map

package/dist/scripts/zellij-real-session-launch-check.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 // @ts-nocheck
 import fs from 'node:fs/promises';
+import { createHash } from 'node:crypto';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
@@ -8,15 +9,47 @@ const freshness = ensureDistFresh({ rebuild: true });
 if (!freshness.ok)
     fail('dist_not_fresh', { freshness });
 const args = process.argv.slice(2);
-const missionId = readArg(args, '--mission') || 'M-zellij-real-check';
-const sessionName = readArg(args, '--session') || 'sks-real';
+const runSuffix = `${process.pid}-${Date.now().toString(36)}`;
+const missionId = readArg(args, '--mission') || `M-zellij-real-check-${runSuffix}`;
+const sessionName = readArg(args, '--session') || `sks-real-${runSuffix}`;
 const requireReal = process.env.SKS_REQUIRE_ZELLIJ === '1' || args.includes('--require-real');
 const mainOnly = args.includes('--main-only') || process.env.SKS_ZELLIJ_MAIN_ONLY === '1';
+const ownedSession = args.includes('--owned-session');
+const ownerToken = String(process.env.SKS_ZELLIJ_CHECK_OWNER_TOKEN || '');
 const launcher = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-launcher.js')).href);
 const command = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-command.js')).href);
 const screenProof = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-screen-proof.js')).href);
-await command.runZellij(['kill-session', sessionName], { cwd: root, timeoutMs: 5000, optional: true });
-await fs.rm(path.join(root, '.sneakoscope', 'missions', missionId), { recursive: true, force: true }).catch(() => null);
+const socketDir = command.resolveZellijProcessEnvMeta().zellij_socket_dir;
+const missionRoot = path.join(root, '.sneakoscope', 'missions', missionId);
+const ownershipPath = path.join(missionRoot, 'zellij-real-session-ownership.json');
+const expectedLayoutPath = path.join(root, '.sneakoscope', 'layouts', `mad-${missionId}.kdl`);
+let ownership = null;
+if (ownedSession) {
+    if (!isSafeOwnedSocketDir(socketDir))
+        fail('zellij_owned_socket_dir_invalid', { socket_dir: socketDir });
+    if (ownerToken.length < 32)
+        fail('zellij_owner_token_missing', { owner_token_present: ownerToken.length > 0 });
+    const [markerExists, socketExists] = await Promise.all([exists(ownershipPath), exists(socketDir)]);
+    if (markerExists)
+        fail('zellij_ownership_marker_collision', { ownership_path: ownershipPath });
+    if (socketExists)
+        fail('zellij_owned_socket_dir_collision', { socket_dir: socketDir });
+    ownership = {
+        schema: 'sks.zellij-real-session-ownership.v1',
+        mission_id: missionId,
+        session_name: sessionName,
+        socket_dir: socketDir,
+        owner_token_sha256: hashOwnerToken(ownerToken),
+        cleanup_authorized: true,
+        layout_cleanup_authorized: true,
+        layout_path: expectedLayoutPath,
+        layout_sha256: null,
+        state: 'prepared',
+        session_created: false
+    };
+    await fs.mkdir(missionRoot, { recursive: true });
+    await fs.writeFile(ownershipPath, `${JSON.stringify(ownership, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
+}
 const report = await launcher.launchMadZellijUi(['--session', sessionName], {
     root,
     missionId,
@@ -25,21 +58,42 @@ const report = await launcher.launchMadZellijUi(['--session', sessionName], {
     requireZellij: requireReal,
     slotCount: 1
 });
+const sessionCollision = Array.isArray(report?.launch?.create_background?.warnings)
+    && report.launch.create_background.warnings.some((warning) => String(warning).startsWith('zellij_session_already_exists:'));
+const layoutPathValid = !ownedSession || path.resolve(String(report?.layout_path || '')) === path.resolve(expectedLayoutPath);
+const layoutSha256 = ownedSession && layoutPathValid ? await sha256File(expectedLayoutPath) : null;
+if (ownership) {
+    ownership = {
+        ...ownership,
+        state: report?.launch?.create_background?.ok === true && !sessionCollision ? 'launched' : 'launch_failed',
+        session_created: report?.launch?.create_background?.ok === true && !sessionCollision,
+        layout_path_valid: layoutPathValid,
+        layout_sha256: layoutSha256,
+        launch_exit_code: report?.launch?.create_background?.exit_code ?? null
+    };
+    await fs.writeFile(ownershipPath, `${JSON.stringify(ownership, null, 2)}\n`, { mode: 0o600 });
+}
 const heartbeatPath = path.join(root, '.sneakoscope', 'missions', missionId, 'zellij-lane-renderer-heartbeat.jsonl');
 const heartbeat = mainOnly
     ? { ok: true, heartbeat_present: false, waited_ms: 0, timeout_ms: 0, blocker: null, skipped: true }
     : await screenProof.waitForLaneHeartbeat(heartbeatPath, { timeoutMs: 5000 });
 const blockers = [
+    ...(sessionCollision ? ['zellij_session_name_collision'] : []),
+    ...(ownedSession && !layoutPathValid ? ['zellij_owned_layout_path_invalid'] : []),
+    ...(ownedSession && !layoutSha256 ? ['zellij_owned_layout_hash_missing'] : []),
     ...(requireReal && report.ok !== true ? ['zellij_real_session_launch_failed'] : []),
     ...(requireReal && heartbeat.blocker ? [heartbeat.blocker] : [])
 ];
 const gate = {
     schema: 'sks.zellij-real-session-launch-check.v1',
-    ok: requireReal ? (report.ok === true && heartbeat.ok === true && blockers.length === 0) : report.ok === true,
+    ok: requireReal ? (report.ok === true && heartbeat.ok === true && blockers.length === 0) : (report.ok === true && blockers.length === 0),
     integration_optional: !requireReal,
     main_only: mainOnly,
     mission_id: missionId,
     session_name: sessionName,
+    owned_session: ownedSession,
+    ownership_path: ownership ? ownershipPath : null,
+    socket_dir: socketDir,
     heartbeat: { path: heartbeatPath, present: heartbeat.heartbeat_present, waited_ms: heartbeat.waited_ms, timeout_ms: heartbeat.timeout_ms },
     blockers,
     report
@@ -54,4 +108,21 @@ function readArg(args, name) {
     const index = args.indexOf(name);
     return index >= 0 ? args[index + 1] || null : null;
 }
+function hashOwnerToken(value) {
+    return createHash('sha256').update(String(value)).digest('hex');
+}
+async function sha256File(file) {
+    return fs.readFile(file).then((data) => createHash('sha256').update(data).digest('hex')).catch(() => null);
+}
+function isSafeOwnedSocketDir(value) {
+    if (!value)
+        return false;
+    const resolved = path.resolve(String(value));
+    return path.dirname(resolved) === '/tmp' && /^sks-zj-rr-[A-Za-z0-9-]+$/.test(path.basename(resolved));
+}
+async function exists(value) {
+    if (!value)
+        return false;
+    return fs.access(value).then(() => true).catch(() => false);
+}
 //# sourceMappingURL=zellij-real-session-launch-check.js.map

package/dist/scripts/zellij-slot-pane-renderer-check.js

@@ -15,7 +15,7 @@ const text = renderer.renderZellijSlotPane({
     serviceTier: 'fast',
     provider: 'codex-lb',
     authMode: 'codex_lb_key',
-    model: 'gpt-5.5',
+    model: 'gpt-5.6-terra',
     reasoningEffort: 'medium',
     currentFile: 'src/core/foo.ts',
     currentTask: 'Editing Zellij slot pane renderer',
@@ -56,7 +56,7 @@ await fs.writeFile(path.join(artifactDir, 'zellij-worker-pane.json'), JSON.strin
 }, null, 2));
 await fs.writeFile(path.join(artifactDir, 'codex-control-proof.json'), JSON.stringify({
     config: {
-        model: 'gpt-5.5',
+        model: 'gpt-5.6-terra',
         model_provider: 'codex-lb',
         service_tier: 'fast',
         model_reasoning_effort: 'medium'
@@ -134,10 +134,10 @@ const report = {
     max_compact_lines: 14,
     contains_slot: /┌─ slot-003/.test(text) && /slot-003/.test(text),
     contains_status: /coding/.test(text),
-    contains_runtime: /gpt-5\.5·fast/.test(text),
+    contains_runtime: /gpt-5\.6-terra·fast/.test(text),
     contains_files: /src\/core\/foo\.ts/.test(text),
     contains_live_event: /renderer updated live pane output/.test(text),
-    artifact_hydrates_runtime: /gpt-5\.5·fast/.test(hydrated),
+    artifact_hydrates_runtime: /gpt-5\.6-terra·fast/.test(hydrated),
     artifact_hydrates_live_event: /renderer stdout tail/.test(hydrated),
     artifact_hydrates_planned_file: /zellij-slot-pane-renderer\.ts/.test(hydrated),
     mission_live_telemetry_wins: /mission telemetry stale fixture/.test(missionHydrated) && /renderer stdout tail/.test(missionHydrated),

package/dist/scripts/zellij-spawn-on-demand-layout-check.js

@@ -5,7 +5,7 @@ import { packageRoot } from '../core/fsx.js';
 import { buildZellijLayoutKdl, validateZellijLayoutKdl, writeZellijLayout } from '../core/zellij/zellij-layout-builder.js';
 const root = packageRoot();
 const tmpRoot = path.join(root, '.sneakoscope', 'tmp', 'spawn-on-demand-layout-check');
-process.env.SKS_ZELLIJ_VIEWPORTS = '4';
+process.env.SKS_ZELLIJ_VIEWPORTS = '3';
 const built = buildZellijLayoutKdl({ missionId: 'M-spawn-on-demand-layout', ledgerRoot: tmpRoot, cwd: root, kind: 'naruto', slotCount: 24 });
 const validation = validateZellijLayoutKdl(built.layout_kdl);
 const writeBuilt = await writeZellijLayout(root, { missionId: 'M-spawn-on-demand-layout-write', ledgerRoot: tmpRoot, cwd: root, kind: 'agent', slotCount: 5 });
@@ -15,11 +15,11 @@ const viewportPaneMatches = built.layout_kdl.match(/pane name="sks-viewport-/g)
 const laneCommandMatches = built.layout_kdl.match(/\bzellij-lane\b/g) || [];
 const ok = validation.ok
     && built.initial_worker_panes === 0
-    && built.viewport_count === 4
+    && built.viewport_count === 3
     && built.ui_architecture === 'monitor_plus_viewports'
     && built.lane_runtime_policies.length === 0
     && workerPaneMatches.length === 0
-    && viewportPaneMatches.length === 4
+    && viewportPaneMatches.length === 3
     && laneCommandMatches.length === 0
     && manifest.lanes.length === 0
     && writeBuilt.initial_worker_panes === 0;

package/docs/demo.tape

@@ -23,6 +23,6 @@ Type "sks ui --once"
 Enter
 Sleep 1s
 
-Type "sks naruto run \"demo no-op swarm\" --backend fake --clones 4 --work-items 4 --no-open-zellij --json"
+Type "sks naruto run \"demo official subagent workflow\" --agents 4 --max-threads 4 --json"
 Enter
 Sleep 2s