sneakoscope 8.0.2 → 8.0.4

package/dist/core/zellij/zellij-worker-pane-summary.js

@@ -1,64 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { readJson, readText, writeJsonAtomic } from '../fsx.js';
-export async function buildZellijWorkerPaneSummary(root, missionId) {
-    const missionDir = path.join(path.resolve(root), '.sneakoscope', 'missions', missionId);
-    const ledgerRows = await readJsonl(path.join(path.resolve(root), 'agent-zellij-pane-launch-ledger.jsonl'));
-    const missionRows = ledgerRows.filter((row) => !row.mission_id || row.mission_id === missionId);
-    const state = await readJson(path.join(missionDir, 'zellij-right-column-state.json'), null);
-    const metrics = await readJsonl(path.join(missionDir, 'zellij', 'pane-creation-lock-events.jsonl'));
-    const requested = missionRows.filter((row) => row.worker_stacked_requested === true);
-    const applied = missionRows.filter((row) => row.worker_stacked_applied === true);
-    const fallbackRows = missionRows.filter((row) => row.worker_stacked_requested === true && row.worker_stacked_applied !== true);
-    const fallbackModes = {};
-    for (const row of fallbackRows) {
-        const mode = String(row.worker_stacked_fallback_mode || 'unknown');
-        fallbackModes[mode] = (fallbackModes[mode] || 0) + 1;
-    }
-    const anchors = new Set([
-        ...missionRows.map((row) => row.slot_column_anchor_pane_id).filter(Boolean).map(String),
-        ...(state?.slot_column_anchor_pane_id ? [String(state.slot_column_anchor_pane_id)] : [])
-    ]);
-    const stackedCapable = missionRows.some((row) => row.worker_stacked_capability?.supports_stacked_panes === true);
-    const waitP95 = percentile(metrics.map((row) => Number(row.wait_ms || 0)), 0.95);
-    const heldP95 = percentile(metrics.map((row) => Number(row.held_ms || 0)), 0.95);
-    const blockers = [
-        ...(anchors.size > 1 ? ['zellij_duplicate_slot_anchor_count_gt_1'] : []),
-        ...(requested.length > 0 && applied.length === 0 && stackedCapable ? ['zellij_stacked_requested_but_none_applied'] : []),
-        ...(waitP95 > 5000 && requested.length <= 1 ? ['zellij_pane_lock_wait_high_with_low_concurrency'] : [])
-    ];
-    const summary = {
-        schema: 'sks.zellij-worker-pane-summary.v1',
-        ok: blockers.length === 0,
-        mission_id: missionId,
-        stacked_requested_count: requested.length,
-        stacked_applied_count: applied.length,
-        stacked_fallback_count: fallbackRows.length,
-        fallback_modes: fallbackModes,
-        pane_lock_wait_p95_ms: waitP95,
-        pane_lock_held_p95_ms: heldP95,
-        duplicate_slot_anchor_count: anchors.size,
-        blockers
-    };
-    await writeJsonAtomic(path.join(missionDir, 'zellij-worker-pane-summary.json'), summary);
-    await writeJsonAtomic(path.join(path.resolve(root), '.sneakoscope', 'reports', 'zellij-worker-pane-summary.json'), summary);
-    return summary;
-}
-async function readJsonl(file) {
-    const text = await readText(file, '').catch(() => '');
-    return String(text || '').split(/\n+/).filter(Boolean).flatMap((line) => {
-        try {
-            return [JSON.parse(line)];
-        }
-        catch {
-            return [];
-        }
-    });
-}
-function percentile(values, p) {
-    const sorted = values.filter((value) => Number.isFinite(value)).sort((a, b) => a - b);
-    if (!sorted.length)
-        return 0;
-    const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * p) - 1));
-    return Math.round(sorted[index] || 0);
-}

package/dist/native/sks-menubar/Tests/AppRuntimeTestSupport.swift

@@ -1,26 +0,0 @@
-#if SKS_NATIVE_TESTING
-import Foundation
-import Darwin
-
-private func sksCanonicalFilesystemPath(_ value: String) -> String {
-    let standardized = URL(fileURLWithPath: value, isDirectory: true)
-        .resolvingSymlinksInPath().standardizedFileURL.path
-    return standardized.withCString { pointer in
-        guard let resolved = Darwin.realpath(pointer, nil) else { return standardized }
-        defer { free(resolved) }
-        return String(cString: resolved)
-    }
-}
-
-enum AppRuntime {
-    static let actionScript = "/tmp/sks-menubar-action.sh"
-    static let projectRoot = "/tmp/sks-menubar-project"
-    static let canonicalProjectRoot = sksCanonicalFilesystemPath(projectRoot)
-    static let buildStampPath = "/tmp/sks-menubar-build-stamp.json"
-    static let configPath = "/tmp/sks-menubar-config.json"
-    static let lastActionLogPath = "/tmp/sks-menubar-last-action.log"
-    static let operationDirectory = "/tmp/sks-menubar-operations"
-    static let codexBundleId: String? = nil
-    static let packageVersion = "test"
-}
-#endif

package/dist/native/sks-menubar/Tests/OperationCoordinatorTests.swift

@@ -1,174 +0,0 @@
-#if canImport(XCTest)
-import Foundation
-import XCTest
-
-final class OperationCoordinatorTests: XCTestCase {
-    func testCompletedSixteenStageUpdateReceiptIsAcceptedAndReleasesMutationGuard() throws {
-        let directory = FileManager.default.temporaryDirectory
-            .appendingPathComponent("sks-operation-coordinator-\(UUID().uuidString)", isDirectory: true)
-        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
-        defer { try? FileManager.default.removeItem(at: directory) }
-
-        let registry = "https://registry.npmjs.org/"
-        let coordinator = OperationCoordinator(directory: directory.path)
-        let operation = try XCTUnwrap(
-            coordinator.begin(
-                kind: "update",
-                mutationGroup: "update",
-                summary: "Update SKS",
-                targetVersion: "8.0.2",
-                projectRoot: AppRuntime.canonicalProjectRoot,
-                registry: registry
-            )
-        )
-        let receiptURL = directory.appendingPathComponent("update-latest.json")
-        let stages = OperationCoordinator.updateStageOrder.enumerated().map { index, id in
-            [
-                "id": id,
-                "ok": true,
-                "status": "completed",
-                "updated_at": "2026-07-30T00:00:\(String(format: "%02d", index)).000Z"
-            ] as [String: Any]
-        }
-        let receipt: [String: Any] = [
-            "schema": "sks.update-operation.v1",
-            "id": operation.id,
-            "kind": "update",
-            "state": "succeeded",
-            "current_stage": "snapshot_refresh",
-            "started_at": "2026-07-30T00:00:00.000Z",
-            "updated_at": "2026-07-30T00:00:16.000Z",
-            "from_version": "8.0.1",
-            "target_version": "8.0.2",
-            "previous_version": "8.0.1",
-            "project_root": AppRuntime.canonicalProjectRoot,
-            "registry": registry,
-            "rollback_command": "sks update rollback --version 8.0.1 --project-root \(AppRuntime.canonicalProjectRoot) --json",
-            "side_effects_started": true,
-            "stages": stages,
-            "result_status": "updated",
-            "receipt_path": receiptURL.path
-        ]
-        let data = try JSONSerialization.data(withJSONObject: receipt, options: [.sortedKeys])
-        try data.write(to: receiptURL, options: .atomic)
-        try FileManager.default.setAttributes([.posixPermissions: 0o600], ofItemAtPath: receiptURL.path)
-
-        XCTAssertEqual(OperationCoordinator.updateStageOrder.count, 16)
-        XCTAssertTrue(OperationCoordinator.updateStageOrder.contains("update_finalize_doctor"))
-
-        let loaded = try XCTUnwrap(coordinator.latestUpdateReceipt())
-        XCTAssertEqual(loaded.stages.count, 16)
-        XCTAssertEqual(loaded.registry, registry)
-        XCTAssertTrue(OperationCoordinator.receiptMatchesLaunchedUpdate(loaded, operation: operation))
-        XCTAssertNil(
-            coordinator.begin(kind: "overlap", mutationGroup: "update", summary: "Overlapping update"),
-            "Polling a receipt must not release the mutation guard before the process result is validated."
-        )
-        _ = coordinator.update(
-            operation,
-            state: .terminalUncertain,
-            stage: "receipt",
-            progress: nil,
-            summary: "Unvalidated final output"
-        )
-        let retryAfterUncertain = try XCTUnwrap(
-            coordinator.begin(kind: "unverified-retry", mutationGroup: "update", summary: "Unverified retry"),
-            "Once the owned process has completed, an uncertain receipt must not permanently disable later Center mutations."
-        )
-        _ = coordinator.update(
-            retryAfterUncertain,
-            state: .cancelled,
-            stage: "cancelled",
-            progress: 1,
-            summary: "Test cleanup"
-        )
-
-        let synchronized = coordinator.synchronize(operation, with: loaded, processCompleted: true)
-        let projectBound = coordinator.synchronize(
-            operation,
-            with: loaded,
-            processCompleted: true,
-            expectedProjectRoot: AppRuntime.canonicalProjectRoot
-        )
-        XCTAssertEqual(projectBound.state, .succeeded)
-        XCTAssertEqual(synchronized.progress, 1)
-        XCTAssertTrue(
-            OperationCoordinator.completionContractIssues(
-                for: loaded,
-                expectedProjectRoot: AppRuntime.canonicalProjectRoot
-            ).isEmpty
-        )
-        XCTAssertNotNil(
-            coordinator.begin(kind: "next-update", mutationGroup: "update", summary: "Retry update"),
-            "A terminal authoritative receipt must release the mutation guard for later Center actions."
-        )
-    }
-
-    func testUpdateReceiptBindingRejectsIdentityAndReviewContractMismatches() throws {
-        let directory = FileManager.default.temporaryDirectory
-            .appendingPathComponent("sks-operation-binding-\(UUID().uuidString)", isDirectory: true)
-        defer { try? FileManager.default.removeItem(at: directory) }
-        let coordinator = OperationCoordinator(directory: directory.path)
-        let operation = try XCTUnwrap(
-            coordinator.begin(
-                kind: "update",
-                mutationGroup: "update",
-                summary: "Update SKS",
-                targetVersion: "8.0.2",
-                projectRoot: AppRuntime.canonicalProjectRoot,
-                registry: "https://registry.npmjs.org/"
-            )
-        )
-        func receipt(
-            id: String? = nil,
-            kind: String = "update",
-            target: String? = "8.0.2",
-            projectRoot: String? = AppRuntime.canonicalProjectRoot,
-            registry: String? = "https://registry.npmjs.org/"
-        ) -> UpdateOperationReceiptSnapshot {
-            UpdateOperationReceiptSnapshot(
-                schema: "sks.update-operation.v1",
-                id: id ?? operation.id,
-                kind: kind,
-                state: "running",
-                currentStage: "preflight",
-                startedAt: operation.startedAt,
-                updatedAt: operation.updatedAt,
-                fromVersion: "8.0.1",
-                targetVersion: target,
-                previousVersion: "8.0.1",
-                projectRoot: projectRoot,
-                registry: registry,
-                rollbackCommand: "sks update rollback --version 8.0.1 --json",
-                sideEffectsStarted: false,
-                stages: [],
-                resultStatus: nil,
-                publicError: nil,
-                receiptPath: directory.appendingPathComponent("update-latest.json").path
-            )
-        }
-
-        XCTAssertTrue(OperationCoordinator.receiptMatchesLaunchedUpdate(receipt(), operation: operation))
-        XCTAssertFalse(OperationCoordinator.receiptMatchesLaunchedUpdate(receipt(id: "other-operation"), operation: operation))
-        XCTAssertFalse(OperationCoordinator.receiptMatchesLaunchedUpdate(receipt(kind: "rollback"), operation: operation))
-        XCTAssertFalse(OperationCoordinator.receiptMatchesLaunchedUpdate(receipt(target: "8.0.3"), operation: operation))
-        XCTAssertFalse(OperationCoordinator.receiptMatchesLaunchedUpdate(receipt(projectRoot: "/different/project"), operation: operation))
-        XCTAssertFalse(OperationCoordinator.receiptMatchesLaunchedUpdate(receipt(registry: "https://registry.example/"), operation: operation))
-        XCTAssertFalse(OperationCoordinator.receiptMatchesLaunchedUpdate(receipt(registry: "https://registry.npmjs.org"), operation: operation))
-    }
-
-    func testRegistryCanonicalizationMatchesUpdateContract() {
-        XCTAssertEqual(
-            OperationCoordinator.canonicalRegistry("https://registry.npmjs.org"),
-            "https://registry.npmjs.org/"
-        )
-        XCTAssertEqual(
-            OperationCoordinator.canonicalRegistry("https://registry.npmjs.org/#ignored"),
-            "https://registry.npmjs.org/"
-        )
-        XCTAssertNil(OperationCoordinator.canonicalRegistry("file:///tmp/registry"))
-        XCTAssertNil(OperationCoordinator.canonicalRegistry("https://token@registry.npmjs.org/"))
-        XCTAssertNil(OperationCoordinator.canonicalRegistry("https://registry.npmjs.org/?token=secret"))
-    }
-}
-#endif

package/dist/native/sks-menubar/Tests/ProcessClientTests.swift

@@ -1,20 +0,0 @@
-#if canImport(XCTest)
-import XCTest
-
-final class ProcessClientTests: XCTestCase {
-    func testNativeTimeoutAndEmptyOutputAreStablePublicErrors() {
-        XCTAssertEqual(
-            ProcessClient.nativeFailureOutput("native_process_timeout"),
-            #"{"schema":"sks.native-process-error.v1","ok":false,"error":"native_process_timeout"}"#
-        )
-        XCTAssertEqual(
-            ProcessClient.nativeFailureOutput("native_process_empty_output"),
-            #"{"schema":"sks.native-process-error.v1","ok":false,"error":"native_process_empty_output"}"#
-        )
-        XCTAssertEqual(
-            ProcessClient.nativeFailureOutput("native_process_output_limit"),
-            #"{"schema":"sks.native-process-error.v1","ok":false,"error":"native_process_output_limit"}"#
-        )
-    }
-}
-#endif

package/dist/native/sks-menubar/Tests/ProvidersViewControllerTests.swift

@@ -1,142 +0,0 @@
-#if canImport(XCTest)
-import XCTest
-
-final class ProvidersViewControllerTests: XCTestCase {
-    func testUnsignedStructuredCapabilityJSONCannotVerify() {
-        let fabricated: [String: Any] = [
-            "overall": "verified",
-            "image_generation": ["state": "verified", "source": "deep_probe"],
-            "computer_use": ["state": "verified", "source": "deep_probe"]
-        ]
-        XCTAssertFalse(CapabilityVerificationTruth.deepEvidenceTrusted(in: fabricated))
-    }
-
-    func testTrustedValidationRequiresExactVerifiedAttestation() {
-        let trusted: [String: Any] = [
-            "overall": "verified",
-            "deep_evidence_validation": [
-                "schema": "sks.codex-lb-deep-evidence-validation.v1",
-                "state": "verified",
-                "trusted": true,
-                "blockers": []
-            ]
-        ]
-        XCTAssertTrue(CapabilityVerificationTruth.deepEvidenceTrusted(in: trusted))
-    }
-
-    func testStructuredBlockersArePreservedForFailureRendering() {
-        let blocked: [String: Any] = [
-            "overall": "blocked",
-            "image_generation": [
-                "state": "blocked",
-                "blockers": ["codex_lb_deep_evidence_stale"]
-            ]
-        ]
-        XCTAssertEqual(
-            CapabilityVerificationTruth.blockers(in: blocked),
-            ["codex_lb_deep_evidence_stale"]
-        )
-    }
-
-    func testStatusV2BuiltinOpenAISelectionIsChatGPTOauthModeNotLegacyCodexLb() {
-        let status: [String: Any] = [
-            "schema": "sks.codex-lb-status.v2",
-            "ok": true,
-            "configured": true,
-            "mode": "cli-provider",
-            "oauth": [
-                "present": true,
-                "preserved": true,
-                "mode": "chatgpt_oauth"
-            ],
-            "provider": [
-                "id": "openai",
-                "built_in": true,
-                "contract": "codex-lb-cli",
-                "contract_ok": true,
-                "selected": true
-            ],
-            "bridge": [
-                "key_fingerprint": "sha256:fixture"
-            ]
-        ]
-        let snapshot = ProviderRoutingTruth.snapshot(from: status)
-        XCTAssertEqual(snapshot.mode, "cli-provider")
-        XCTAssertFalse(snapshot.desktopFullRouting)
-        XCTAssertFalse(snapshot.legacyCodexLbSelected)
-        XCTAssertTrue(snapshot.chatgptOauthPresent)
-        XCTAssertTrue(snapshot.cliProviderStored)
-        XCTAssertTrue(snapshot.cliCredentialsConfigured)
-    }
-
-    func testStatusV2DesktopBridgeModeIsSelectableCodexLb() {
-        let status: [String: Any] = [
-            "schema": "sks.codex-lb-status.v2",
-            "configured": true,
-            "mode": "desktop-native-bridge",
-            "oauth": [
-                "present": true,
-                "mode": "chatgpt_oauth"
-            ],
-            "provider": [
-                "id": "openai",
-                "selected": true,
-                "contract": "builtin-openai"
-            ]
-        ]
-        let snapshot = ProviderRoutingTruth.snapshot(from: status)
-        XCTAssertTrue(snapshot.desktopFullRouting)
-        XCTAssertFalse(snapshot.legacyCodexLbSelected)
-        XCTAssertTrue(snapshot.chatgptOauthPresent)
-    }
-
-    func testStatusV2DetectsLegacyCodexLbWhenBuiltinProviderNotSelected() {
-        let status: [String: Any] = [
-            "mode": "cli-provider",
-            "configured": true,
-            "oauth": ["present": false, "mode": "openai_api_key"],
-            "provider": [
-                "id": "openai",
-                "selected": false,
-                "contract": "codex-lb-cli"
-            ]
-        ]
-        let snapshot = ProviderRoutingTruth.snapshot(from: status)
-        XCTAssertTrue(snapshot.legacyCodexLbSelected)
-        XCTAssertFalse(snapshot.chatgptOauthPresent)
-    }
-
-    func testStatusV2DoesNotTreatNestedBridgeStatusAsLegacyDestructive() {
-        let status: [String: Any] = [
-            "mode": "cli-provider",
-            "configured": true,
-            "oauth": ["present": true, "mode": "chatgpt_oauth"],
-            "provider": ["id": "openai", "selected": true],
-            "bridge": ["status": "settings_missing"]
-        ]
-        let snapshot = ProviderRoutingTruth.snapshot(from: status)
-        XCTAssertFalse(snapshot.legacyDestructive)
-        XCTAssertFalse(snapshot.legacyCodexLbSelected)
-    }
-
-    func testDisabledChatGPTOauthModeIsNotTreatedAsLegacyCodexLbSelection() {
-        let status: [String: Any] = [
-            "schema": "sks.codex-lb-status.v2",
-            "mode": "disabled",
-            "configured": false,
-            "oauth": ["present": true, "mode": "chatgpt_oauth"],
-            "provider": [
-                "id": "openai",
-                "selected": true,
-                "built_in": true,
-                "contract": "builtin-openai"
-            ]
-        ]
-        let snapshot = ProviderRoutingTruth.snapshot(from: status)
-        XCTAssertEqual(snapshot.mode, "disabled")
-        XCTAssertFalse(snapshot.desktopFullRouting)
-        XCTAssertFalse(snapshot.legacyCodexLbSelected)
-        XCTAssertTrue(snapshot.chatgptOauthPresent)
-    }
-}
-#endif

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

@@ -1,88 +0,0 @@
-#!/usr/bin/env node
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
-const freshness = ensureDistFresh({ rebuild: true });
-if (!freshness.ok)
-    fail('dist_not_fresh', { freshness });
-const mod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-pane-proof.js')).href);
-const args = process.argv.slice(2);
-const missionId = readArg(args, '--mission');
-const sessionName = readArg(args, '--session');
-const expectedLaneArg = readArg(args, '--expected-lanes');
-const expectedLaneCount = expectedLaneArg === null ? undefined : Number(expectedLaneArg);
-const report = await mod.writeZellijPaneProof(root, {
-    require: process.env.SKS_REQUIRE_ZELLIJ === '1' || args.includes('--require-real'),
-    missionId: missionId || undefined,
-    sessionName: sessionName || undefined,
-    expectedLaneCount,
-    ledgerRoot: missionId ? path.join(root, '.sneakoscope', 'missions', missionId) : undefined
-});
-const positive = mod.evaluateZellijPaneProofRows(mod.normalizeZellijPaneRows([
-    { pane_id: '1', name: 'orchestrator', command: 'sh -lc sks status --json', cwd: root, exited: false, x: 0, y: 0, width: 80, height: 24 },
-    { pane_id: '2', name: 'slot-001', command: 'sh -lc sks zellij-lane --mission M --slot slot-001', cwd: root, exited: false, x: 80, y: 0, width: 40, height: 24 }
-]), { expectedLaneCount: 1, expectedCwd: root });
-const missingLane = mod.evaluateZellijPaneProofRows(mod.normalizeZellijPaneRows([
-    { pane_id: '1', name: 'orchestrator', command: 'sh', cwd: root, exited: false }
-]), { expectedLaneCount: 1, expectedCwd: root });
-const exitedLane = mod.evaluateZellijPaneProofRows(mod.normalizeZellijPaneRows([
-    { pane_id: '1', name: 'orchestrator', command: 'sh', cwd: root, exited: false },
-    { pane_id: '2', name: 'slot-001', command: 'sks zellij-lane --mission M --slot slot-001', cwd: root, exited: true }
-]), { expectedLaneCount: 1, expectedCwd: root });
-const madCodexMain = mod.evaluateZellijPaneProofRows(mod.normalizeZellijPaneRows([
-    { pane_id: '1', name: 'orchestrator', command: 'codex --profile sks-mad-high', 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 madShellMain = mod.evaluateZellijPaneProofRows(mod.normalizeZellijPaneRows([
-    { pane_id: '1', name: 'orchestrator', command: 'sh -lc sks status --json', 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 codexLbOnlyMain = mod.evaluateZellijPaneProofRows(mod.normalizeZellijPaneRows([
-    { 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')
-    && 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); }
-function readArg(args, name) {
-    const index = args.indexOf(name);
-    return index >= 0 ? args[index + 1] || null : null;
-}

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

@@ -1,139 +0,0 @@
-#!/usr/bin/env node
-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';
-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 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); }
-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);
-}