sneakoscope 1.21.6 → 1.21.7

package/README.md

@@ -16,40 +16,26 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## Current Release
 
-SKS **1.21.6** promotes OpenAI Codex CLI `rust-v0.136.0` as the current compatibility baseline. The release matrix tracks 0.136 session archive/unarchive, app-server `--stdio`, resumed-turn/status behavior, `CODEX_API_KEY` remote registration, short-lived remote-control tokens, elevated Windows sandbox setup, feature-gated image-generation extension support, ChatGPT auth refresh handling, command-safety hardening, sandbox cleanup, Bedrock region fallback, and rmcp 1.7.0 compatibility.
+SKS **1.21.7** is a Zellij/Naruto runtime patch. Real Zellij workers now run as pane-bound native CLI sessions: SKS creates or targets the Zellij session, splits a named slot pane, launches the worker inside that pane, and reads `worker-result.json` plus heartbeat/log artifacts back in the parent scheduler.
 
-This release also tightens the day-to-day operator path:
+What changed:
 
-- Zellij lane panes now surface the native worker session they are following, including per-slot worker status and stdout/stderr/heartbeat tails.
-- Native terminal drag-copy is the default in SKS-launched Zellij sessions; hover-pane mouse routing is opt-in with `SKS_ZELLIJ_MOUSE_MODE=1`.
-- Update prompts compare npm latest against an effective installed version that includes source, PATH, and global npm package metadata, so completed global updates stop being re-offered.
-- `sks doctor --fix` can remove duplicate global `sks`/`sneakoscope` npm installs while exempting the Sneakoscope source checkout.
+- `--backend zellij --real` now uses real slot panes for worker sessions instead of only recording synthetic lane artifacts.
+- Pane ids are reconciled from `zellij --session <name> action list-panes --json --all` when `new-pane` does not print one.
+- The parent/worker transport is explicit: `worker-result.json`, `worker-heartbeat.jsonl`, `worker.stdout.log`, and `worker.stderr.log`.
+- Zellij lane supervisor actions target the intended session with `--session`, so pane creation no longer depends on ambient terminal state.
 
-It carries forward the 0.135-era routing/readiness fixes: mixed frustration plus explicit implementation prompts still route to `$Team`, bare `context7 mcp` no longer implies `$DB`, Git Actions readiness uses the `codex remote-control` command/version capability, and repeated substantive prompts prepare fresh Team/Research-style native sessions. Zellij lane, Naruto, terminal scrollback, MAD cockpit, Goal bridge, and Fast profile fixes remain in place.
-
-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. In 1.21.3 and newer, the explicit `on` action also restores Codex App/CLI Fast mode defaults in `~/.codex/config.toml` when they were disabled.
-
-It carries forward the **1.20.2** stabilization layer: **Mutation Guard** routes genuinely-risky global/config/permission/package mutations through the Requested-Scope Contract + Mutation Ledger (`safety:mutation-callsite-coverage` fails any unguarded, unallowlisted risky call site); `release:check:dynamic:execute` is the real **caching gate runner** (schema v2, real/heavy gates deferred to `release:real-check`, dynamic-only cannot authorize publish); the **Core Skill** deployed snapshot is read by the route runtime and recorded in `agent-proof-evidence.json` (`selected_core_skill`), with promotions written to the mutation ledger; and `sks doctor` exposes an explicit **`zellij_readiness`** block (`zellij:doctor-readiness`). See `docs/dynamic-release-pipeline.md`.
-
-SKS **1.20.1** introduces the **SKS Core Skill Engine** — a SkillOpt-style self-evolving skill layer — while locking the harness into a deploy-ready stable build. Skills are the agent's *external, versioned state* (Core Skill Cards): an optimizer proposes **bounded** add/delete/replace edits to a single skill document under a **textual edit budget**, edits are accepted **only on strict held-out improvement**, rejected edits are buffered so they are never retried, and the **deployed snapshot is immutable**. Critically, the optimizer runs only in training/evaluation — the **deployment/inference path reads the deployed snapshot and never makes an extra model call**, and a skill patch can never mutate code/config/package/global files.
-
-1.20.1 also adds a **Requested-Scope Contract + Mutation Ledger** so SKS performs **no side effect the user did not request** (deny-by-default; global/destructive mutations require explicit `--yes`/env opt-in and a backup or no-op reason), and a **dynamic, risk-based release pipeline** (`release:gate-planner` builds `release-gates.json`; `release:check:dynamic` runs only P0 always-on gates plus gates whose files changed; `release:gate-budget` reports the slowest gates) so unrelated heavy gates are skipped during incremental checks while publish never skips a required gate.
-
-It carries forward the 1.19.x hardening unchanged: legacy 1.18.x/1.19.x→1.20.1 **zero-break upgrade** (user `model`/`service_tier`/`model_reasoning_effort` and user-disabled Codex App flags never overwritten; existing skill cards preserved), the **migration transaction journal** (`.sneakoscope/reports/migration-1.20.1-journal.jsonl`), **Zellij launch-command truth** + real-session **heartbeat-timeout blocker** + the redesigned **Zellij lane UI**, **packlist/publish-performance** gates, a **postinstall safe-side-effects** gate, and the **TS source-of-truth / Rust optional-accelerator** boundary (publish never compiles Rust). `sks zellij status`/`repair` inspects the Zellij runtime without auto-installing anything.
-
-Core release checks:
+Quick checks:
 
 ```bash
-npm run codex:0.136-compat
+npm run typecheck
+npm run build
+npm run agent:zellij-runtime
+npm run zellij:layout-valid
 npm run zellij:lane-renderer
-npm run mad-sks:zellij-launch
-npm run release:readiness
-npm run release:check
 ```
 
-Detailed release history lives in [CHANGELOG.md](CHANGELOG.md); every version-facing change should be recorded there before release. Current release gate status lives in [docs/release-readiness.md](docs/release-readiness.md).
+Broader release checks still live behind `npm run release:check`. Detailed release history is in [CHANGELOG.md](CHANGELOG.md), and release readiness is tracked in [docs/release-readiness.md](docs/release-readiness.md).
 
 ## Parallelism, UX, And Integrations
 

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

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

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

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

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

@@ -1,8 +1,8 @@
 {
   "schema": "sks.dist-build-stamp.v1",
   "package_name": "sneakoscope",
-  "package_version": "1.21.6",
-  "source_digest": "3577af7555600bd9748b9c3252bf18a727db23c92740e7a06dc778b467aa1495",
+  "package_version": "1.21.7",
+  "source_digest": "2c5c05c578c385f3e186f4e94b7387c6122093fbba7235ad2c009d4803e1d6b4",
   "source_file_count": 1771,
-  "built_at_source_time": 1780391165608
+  "built_at_source_time": 1780395828537
 }

package/dist/bin/sks.js

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

package/dist/build-manifest.json

@@ -1,13 +1,13 @@
 {
   "schema": "sks.dist-build.v2",
-  "version": "1.21.6",
-  "package_version": "1.21.6",
+  "version": "1.21.7",
+  "package_version": "1.21.7",
   "typescript": true,
   "mjs_runtime_files": 0,
   "compiled_file_count": 1032,
   "compiled_js_count": 516,
   "compiled_dts_count": 516,
-  "source_digest": "3577af7555600bd9748b9c3252bf18a727db23c92740e7a06dc778b467aa1495",
+  "source_digest": "2c5c05c578c385f3e186f4e94b7387c6122093fbba7235ad2c009d4803e1d6b4",
   "source_file_count": 1771,
   "source_files_hash": "1f79c92a7165654f5ae190c1719e7e8ec89337ed8f265c7a68242ef613848f19",
   "source_list_hash": "1f79c92a7165654f5ae190c1719e7e8ec89337ed8f265c7a68242ef613848f19",

package/dist/core/agents/native-cli-session-swarm.d.ts

@@ -15,6 +15,7 @@ declare class NativeCliSessionSwarmRecorder {
     private active;
     private maxObserved;
     private writeLock;
+    private nextPaneToken;
     constructor(root: string, input: {
         missionId: string;
         requestedAgents: number;
@@ -29,6 +30,7 @@ declare class NativeCliSessionSwarmRecorder {
         slice: any;
         opts: any;
     }): Promise<import("./agent-schema.js").AgentRunnerResult>;
+    private launchWorkerInZellijPane;
     finalize(): Promise<{
         schema: string;
         generated_at: string;
@@ -37,6 +39,7 @@ declare class NativeCliSessionSwarmRecorder {
         route: string;
         backend: string;
         scaling_primitive: string;
+        zellij_pane_worker_sessions: number;
         requested_agents: number;
         target_active_slots: number;
         spawned_worker_process_count: number;
@@ -60,5 +63,12 @@ declare class NativeCliSessionSwarmRecorder {
     private persist;
     private summary;
 }
+export declare function buildPaneWorkerCommand(input: {
+    args: string[];
+    stdoutPath: string;
+    stderrPath: string;
+    heartbeatPath: string;
+    env: Record<string, unknown>;
+}): string;
 export {};
 //# sourceMappingURL=native-cli-session-swarm.d.ts.map

package/dist/core/agents/native-cli-session-swarm.js

@@ -1,9 +1,11 @@
 import fs from 'node:fs';
 import { spawn } from 'node:child_process';
 import path from 'node:path';
-import { ensureDir, exists, nowIso, packageRoot, readJson, writeJsonAtomic } from '../fsx.js';
+import { appendJsonl, ensureDir, exists, nowIso, packageRoot, readJson, writeJsonAtomic } from '../fsx.js';
 import { fastModeEnv } from './fast-mode-policy.js';
 import { validateAgentWorkerResult } from './agent-worker-pipeline.js';
+import { runZellij } from '../zellij/zellij-command.js';
+import { extractZellijPaneIdFromOutput, recordZellijLanePaneId } from '../zellij/zellij-lane-runtime.js';
 export const NATIVE_CLI_SESSION_SWARM_SCHEMA = 'sks.agent-native-cli-session-swarm.v1';
 export function createNativeCliSessionSwarmRecorder(root, input) {
     return new NativeCliSessionSwarmRecorder(root, input);
@@ -15,6 +17,7 @@ class NativeCliSessionSwarmRecorder {
     active = new Set();
     maxObserved = 0;
     writeLock = Promise.resolve();
+    nextPaneToken = -1;
     constructor(root, input) {
         this.root = root;
         this.input = input;
@@ -87,6 +90,20 @@ class NativeCliSessionSwarmRecorder {
         };
         const stdout = fs.createWriteStream(path.join(this.root, stdoutRel), { flags: 'a' });
         const stderr = fs.createWriteStream(path.join(this.root, stderrRel), { flags: 'a' });
+        if (this.input.backend === 'zellij' && ctx.opts.real === true && ctx.opts.zellijPaneWorker !== false) {
+            stdout.end();
+            stderr.end();
+            return this.launchWorkerInZellijPane({
+                ctx,
+                record,
+                args,
+                resultRel,
+                stdoutRel,
+                stderrRel,
+                heartbeatRel,
+                workerDirRel
+            });
+        }
         const child = spawn(process.execPath, args, {
             cwd: ctx.opts.cwd || packageRoot(),
             env: {
@@ -154,6 +171,159 @@ class NativeCliSessionSwarmRecorder {
         await this.record(record);
         return result;
     }
+    async launchWorkerInZellijPane(input) {
+        const sessionName = String(input.ctx.opts.zellijSessionName || (this.input.missionId ? `sks-${this.input.missionId}` : 'sks-agent-runtime'));
+        const slotId = String(input.ctx.agent.slot_id || input.ctx.agent.id || 'slot-001');
+        const activeToken = this.nextPaneToken--;
+        this.active.add(activeToken);
+        this.maxObserved = Math.max(this.maxObserved, this.active.size);
+        const workerCommand = buildPaneWorkerCommand({
+            args: input.args,
+            stdoutPath: path.join(this.root, input.stdoutRel),
+            stderrPath: path.join(this.root, input.stderrRel),
+            heartbeatPath: path.join(this.root, input.heartbeatRel),
+            env: {
+                ...(input.ctx.opts.env || {}),
+                ...fastModeEnv(this.input.fastModePolicy),
+                SKS_AGENT_WORKER: '1',
+                SKS_PIPELINE_MODE: 'agent-worker',
+                SKS_DISABLE_ROUTE_RECURSION: '1',
+                SKS_PARENT_MISSION_ID: this.input.missionId,
+                SKS_AGENT_SESSION_ID: String(input.ctx.agent.session_id || ''),
+                SKS_AGENT_SLOT_ID: slotId,
+                SKS_AGENT_GENERATION_INDEX: String(input.ctx.agent.generation_index || 1),
+                SKS_ZELLIJ_WORKER_PANE: '1',
+                SKS_ZELLIJ_SESSION_NAME: sessionName
+            }
+        });
+        const createSession = await runZellij(['attach', '--create-background', sessionName], {
+            cwd: input.ctx.opts.cwd || packageRoot(),
+            timeoutMs: 5000,
+            optional: false
+        });
+        const launch = createSession.ok
+            ? await runZellij(['--session', sessionName, 'action', 'new-pane', '--name', slotId, '--', 'sh', '-lc', workerCommand], {
+                cwd: input.ctx.opts.cwd || packageRoot(),
+                timeoutMs: 5000,
+                optional: false
+            })
+            : null;
+        const stdoutPaneId = launch?.ok ? extractZellijPaneIdFromOutput(launch.stdout_tail) : null;
+        const reconciledPane = stdoutPaneId ? null : launch?.ok ? await reconcileZellijWorkerPaneId(sessionName, slotId, path.join(this.root, input.resultRel), input.ctx.opts.cwd || packageRoot()) : null;
+        const paneId = stdoutPaneId || reconciledPane?.pane_id || null;
+        const paneIdSource = stdoutPaneId ? 'zellij_worker_new_pane_stdout' : reconciledPane?.pane_id ? 'zellij_worker_list_panes' : launch?.ok ? 'zellij_worker_pane_stdout_missing' : 'zellij_worker_pane_launch_failed';
+        const launchBlockers = [
+            ...(createSession.ok ? [] : createSession.blockers.map((blocker) => `zellij_worker_session_${blocker}`)),
+            ...(launch && !launch.ok ? launch.blockers.map((blocker) => `zellij_worker_pane_${blocker}`) : [])
+        ];
+        input.record.command_line = ['zellij', '--session', sessionName, 'action', 'new-pane', '--name', slotId, '--', 'sh', '-lc', '<native-cli-worker-command>'];
+        input.record.zellij_session_name = sessionName;
+        input.record.zellij_pane_id = paneId || null;
+        input.record.zellij_pane_id_source = paneIdSource;
+        input.record.zellij_create_session = createSession;
+        input.record.zellij_launch = launch;
+        input.record.scaling_primitive = 'native_cli_process_in_zellij_pane';
+        input.record.status = launchBlockers.length ? 'failed' : 'running';
+        input.record.blockers = launchBlockers;
+        await this.record(input.record);
+        await appendJsonl(path.join(this.root, 'agent-zellij-pane-launch-ledger.jsonl'), {
+            schema: 'sks.agent-zellij-pane-launch.v1',
+            generated_at: nowIso(),
+            launch_mode: launch?.ok ? 'real_zellij_worker_pane_session' : 'real_zellij_worker_pane_failed',
+            agent_id: input.ctx.agent.id,
+            slot_id: slotId,
+            generation_index: input.ctx.agent.generation_index || null,
+            session_id: input.ctx.agent.session_id,
+            session_name: sessionName,
+            pane_id: paneId || `zellij-pane-${slotId}`,
+            pane_id_source: paneIdSource,
+            command: '<native-cli-worker-command>',
+            worker_artifact_dir: input.workerDirRel,
+            worker_result_path: input.resultRel,
+            parent_child_transport: 'worker-result-json-and-heartbeat',
+            persistent_slot_lane: false,
+            blockers: launchBlockers
+        });
+        await recordZellijLanePaneId(this.root, {
+            slotId,
+            paneId: paneId || `zellij-pane-${slotId}`,
+            source: paneIdSource,
+            sessionName,
+            command: '<native-cli-worker-command>'
+        });
+        await writeJsonAtomic(path.join(this.root, input.workerDirRel, 'zellij-worker-pane-launch.json'), {
+            schema: 'sks.zellij-worker-pane-launch.v1',
+            generated_at: nowIso(),
+            ok: launchBlockers.length === 0,
+            session_name: sessionName,
+            pane_id: paneId || null,
+            pane_id_source: paneIdSource,
+            slot_id: slotId,
+            worker_artifact_dir: input.workerDirRel,
+            result_path: input.resultRel,
+            stdout_log: input.stdoutRel,
+            stderr_log: input.stderrRel,
+            parent_child_transport: 'worker-result-json-and-heartbeat',
+            create_session: createSession,
+            launch,
+            pane_reconciliation: reconciledPane,
+            blockers: launchBlockers
+        });
+        if (launchBlockers.length) {
+            this.active.delete(activeToken);
+            input.record.closed_at = nowIso();
+            input.record.status = 'failed';
+            await this.record(input.record);
+            return validateAgentWorkerResult({
+                mission_id: this.input.missionId,
+                agent_id: input.ctx.agent.id,
+                session_id: input.ctx.agent.session_id,
+                persona_id: input.ctx.agent.persona_id || input.ctx.agent.id,
+                task_slice_id: input.ctx.slice?.id || '',
+                status: 'failed',
+                backend: this.input.backend,
+                summary: 'Zellij worker pane launch failed.',
+                artifacts: [input.stdoutRel, input.stderrRel, path.join(input.workerDirRel, 'zellij-worker-pane-launch.json')],
+                blockers: launchBlockers,
+                unverified: [],
+                writes: [],
+                source_intelligence_refs: input.ctx.agent.source_intelligence_refs || null,
+                goal_mode_ref: input.ctx.agent.goal_mode_ref || null
+            });
+        }
+        const parsed = await waitForWorkerResult(path.join(this.root, input.resultRel), Number(process.env.SKS_ZELLIJ_WORKER_RESULT_TIMEOUT_MS || 120000));
+        this.active.delete(activeToken);
+        input.record.closed_at = nowIso();
+        const workerProcessReport = await readJson(path.join(this.root, input.workerDirRel, 'worker-process-report.json'), null).catch(() => null);
+        input.record.pid = Number(workerProcessReport?.pid) || null;
+        input.record.process_id = input.record.pid;
+        input.record.exit_code = parsed ? (parsed.status === 'done' ? 0 : 1) : 1;
+        input.record.status = parsed?.status === 'done' ? 'closed' : 'failed';
+        input.record.blockers = parsed ? parsed.blockers || [] : ['zellij_worker_result_timeout'];
+        await this.record(input.record);
+        if (!parsed) {
+            return validateAgentWorkerResult({
+                mission_id: this.input.missionId,
+                agent_id: input.ctx.agent.id,
+                session_id: input.ctx.agent.session_id,
+                persona_id: input.ctx.agent.persona_id || input.ctx.agent.id,
+                task_slice_id: input.ctx.slice?.id || '',
+                status: 'failed',
+                backend: this.input.backend,
+                summary: 'Zellij pane worker result timed out.',
+                artifacts: [input.stdoutRel, input.stderrRel, path.join(input.workerDirRel, 'zellij-worker-pane-launch.json')],
+                blockers: ['zellij_worker_result_timeout'],
+                unverified: [],
+                writes: [],
+                source_intelligence_refs: input.ctx.agent.source_intelligence_refs || null,
+                goal_mode_ref: input.ctx.agent.goal_mode_ref || null
+            });
+        }
+        return validateAgentWorkerResult({
+            ...parsed,
+            artifacts: [...new Set([...(Array.isArray(parsed.artifacts) ? parsed.artifacts : []), input.stdoutRel, input.stderrRel, path.join(input.workerDirRel, 'zellij-worker-pane-launch.json')])]
+        });
+    }
     async finalize() {
         await this.persist();
         return this.summary();
@@ -183,6 +353,7 @@ class NativeCliSessionSwarmRecorder {
             route: this.input.route,
             backend: this.input.backend,
             scaling_primitive: 'native_cli_process',
+            zellij_pane_worker_sessions: this.records.filter((row) => row.scaling_primitive === 'native_cli_process_in_zellij_pane').length,
             requested_agents: this.input.requestedAgents,
             target_active_slots: this.input.targetActiveSlots,
             spawned_worker_process_count: this.records.length,
@@ -204,6 +375,69 @@ class NativeCliSessionSwarmRecorder {
         };
     }
 }
+export function buildPaneWorkerCommand(input) {
+    const envPrefix = Object.entries(input.env)
+        .filter(([key, value]) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(key) && value != null)
+        .map(([key, value]) => `${key}=${shellQuote(String(value))}`)
+        .sort();
+    const command = [shellQuote(process.execPath), ...input.args.map(shellQuote)].join(' ');
+    const heartbeat = `printf '%s\\n' ${shellQuote(JSON.stringify({ schema: 'sks.zellij-worker-pane-event.v1', event: 'worker_command_exited' }))} >> ${shellQuote(input.heartbeatPath)}`;
+    const holdMs = Math.max(0, Number(process.env.SKS_ZELLIJ_WORKER_PANE_HOLD_MS || 1500));
+    const hold = holdMs > 0 ? `sleep ${shellQuote(String(Math.min(30, holdMs / 1000)))}` : ':';
+    return `${envPrefix.join(' ')} ${command} > ${shellQuote(input.stdoutPath)} 2> ${shellQuote(input.stderrPath)}; code=$?; ${heartbeat}; ${hold}; exit $code`.trim();
+}
+async function waitForWorkerResult(file, timeoutMs) {
+    const deadline = Date.now() + Math.max(1000, timeoutMs);
+    while (Date.now() < deadline) {
+        const result = await readJson(file, null).catch(() => null);
+        if (result)
+            return result;
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    return null;
+}
+async function reconcileZellijWorkerPaneId(sessionName, slotId, resultPath, cwd) {
+    const listed = await runZellij(['--session', sessionName, 'action', 'list-panes', '--json', '--all'], {
+        cwd,
+        timeoutMs: 5000,
+        optional: true
+    });
+    const rows = parsePaneRows(listed.stdout_tail);
+    const pane = rows.find((row) => {
+        const title = String(row.title || row.name || row.pane_name || '');
+        const command = String(row.terminal_command || row.command || row.command_line || row.running_command || '');
+        const exited = row.exited === true || row.is_exited === true || row.exit_status != null;
+        return !exited && title === slotId && (command.includes(resultPath) || command.includes('SKS_ZELLIJ_WORKER_PANE'));
+    }) || rows.find((row) => {
+        const title = String(row.title || row.name || row.pane_name || '');
+        const exited = row.exited === true || row.is_exited === true || row.exit_status != null;
+        return !exited && title === slotId;
+    });
+    const paneId = pane?.pane_id ?? pane?.paneId ?? pane?.id ?? null;
+    return {
+        schema: 'sks.zellij-worker-pane-reconciliation.v1',
+        ok: Boolean(paneId),
+        pane_id: paneId == null ? null : String(paneId),
+        listed_count: rows.length,
+        command: listed,
+        blockers: paneId == null ? ['zellij_worker_pane_id_not_reconciled'] : []
+    };
+}
+function parsePaneRows(text) {
+    if (!String(text || '').trim())
+        return [];
+    try {
+        const parsed = JSON.parse(String(text));
+        if (Array.isArray(parsed))
+            return parsed;
+        if (Array.isArray(parsed?.panes))
+            return parsed.panes;
+        return [];
+    }
+    catch {
+        return [];
+    }
+}
 async function resolveWorkerCliPath() {
     if (process.env.SKS_NATIVE_WORKER_CLI)
         return process.env.SKS_NATIVE_WORKER_CLI;
@@ -215,4 +449,7 @@ async function resolveWorkerCliPath() {
 function redactWorkerArgs(args) {
     return args.map((arg, index) => index > 0 && args[index - 1] === '--intake' ? '<worker-intake.json>' : arg);
 }
+function shellQuote(value) {
+    return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
 //# sourceMappingURL=native-cli-session-swarm.js.map

package/dist/core/agents/zellij-lane-supervisor.js

@@ -230,7 +230,7 @@ async function createSupervisorLanes(root, missionId, sessionName, targetActiveS
 }
 async function launchPersistentSlotLane(root, lane, missionId) {
     const command = persistentLaneCommandForRoot(root, missionId, lane.slot_id, lane.runtime.session_name);
-    const launch = await runZellij(['action', 'new-pane', '--name', lane.slot_id, '--', 'sh', '-lc', command], { cwd: root, timeoutMs: 5000, optional: true });
+    const launch = await runZellij(['--session', lane.runtime.session_name, 'action', 'new-pane', '--name', lane.slot_id, '--', 'sh', '-lc', command], { cwd: root, timeoutMs: 5000, optional: true });
     const paneId = launch.ok ? extractZellijPaneIdFromOutput(launch.stdout_tail) : null;
     const nextPaneId = paneId || lane.pane_id;
     const paneIdSource = paneId ? 'zellij_new_pane_stdout' : launch.ok ? 'synthetic_fallback_new_pane_stdout_missing' : lane.pane_id_source;

package/dist/core/fsx.d.ts

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

package/dist/core/fsx.js

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

package/dist/core/version.d.ts

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

package/dist/core/version.js

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

package/package.json

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