sneakoscope 2.0.7 → 2.0.8

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

@@ -0,0 +1,179 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { createReleaseGateHermeticEnv } from './release-gate-hermetic-env.js';
+import { appendReleaseGateJsonl, writeReleaseGateJson } from './release-gate-report.js';
+import { findReadyReleaseGateNodes, findReleaseGatesBlockedByFailedDeps, pickReadyLaunchableReleaseGates } from './release-gate-scheduler.js';
+import { readReleaseGateCacheHit, writeReleaseGateCacheHit } from './release-gate-cache-v2.js';
+import { RELEASE_GATE_NODE_SCHEMA, validateReleaseGateManifest } from './release-gate-node.js';
+import { countReleaseGateResources, defaultReleaseGateBudget, summarizeReleaseGateBudget } from './release-gate-resource-governor.js';
+export function loadReleaseGateManifest(root, file = 'release-gates.v2.json') {
+    const manifestPath = path.join(root, file);
+    const parsed = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    const validation = validateReleaseGateManifest(parsed);
+    if (!validation.ok || !validation.manifest) {
+        throw new Error(`invalid ${file}: ${validation.errors.join(', ')}`);
+    }
+    return validation.manifest;
+}
+export async function runReleaseGateDag(input) {
+    const root = path.resolve(input.root);
+    const preset = input.preset || 'release';
+    const manifest = loadReleaseGateManifest(root);
+    const selected = selectPreset(manifest, preset);
+    const runId = `rg-${new Date().toISOString().replace(/[:.]/g, '-')}-${process.pid}`;
+    const reportDir = path.join(root, '.sneakoscope', 'reports', 'release-gates', runId);
+    fs.mkdirSync(reportDir, { recursive: true });
+    const timeline = path.join(reportDir, 'timeline.jsonl');
+    const started = Date.now();
+    const pending = new Map(selected.map((gate) => [gate.id, gate]));
+    const running = new Map();
+    const completed = new Map();
+    const failed = new Map();
+    const budget = defaultReleaseGateBudget();
+    const peakResources = {};
+    let cached = 0;
+    let sumGateMs = 0;
+    let peakRunning = 0;
+    if (input.explain) {
+        writeReleaseGateJson(path.join(reportDir, 'explain.json'), { schema: RELEASE_GATE_NODE_SCHEMA, preset, budget, gates: selected.map((gate) => ({ id: gate.id, deps: gate.deps, resource: gate.resource, command: gate.command })) });
+    }
+    while (pending.size || running.size) {
+        const ready = findReadyReleaseGateNodes({ pending, completed, failed });
+        const launchable = pickReadyLaunchableReleaseGates({ ready, running: [...running.values()].map((row) => row.gate) });
+        let progressed = false;
+        for (const gate of launchable) {
+            pending.delete(gate.id);
+            const cacheHit = !input.noCache && gate.cache.enabled && readReleaseGateCacheHit(root, gate);
+            if (cacheHit) {
+                const result = { id: gate.id, ok: true, exit_code: 0, duration_ms: 0, cached: true, stderr_tail: '' };
+                completed.set(gate.id, result);
+                cached += 1;
+                progressed = true;
+                appendReleaseGateJsonl(timeline, { event: 'cache_hit', gate_id: gate.id, at: new Date().toISOString() });
+                continue;
+            }
+            appendReleaseGateJsonl(timeline, { event: 'start', gate_id: gate.id, resource: gate.resource, at: new Date().toISOString() });
+            running.set(gate.id, { gate, promise: runGate(root, runId, reportDir, gate) });
+            peakRunning = Math.max(peakRunning, running.size);
+            const used = countReleaseGateResources([...running.values()].map((row) => row.gate));
+            for (const [resource, count] of Object.entries(used)) {
+                peakResources[resource] = Math.max(peakResources[resource] || 0, Number(count) || 0);
+            }
+            progressed = true;
+        }
+        if (!running.size) {
+            const blockedByFailedDeps = findReleaseGatesBlockedByFailedDeps({ pending, failed });
+            if (blockedByFailedDeps.length) {
+                for (const gate of blockedByFailedDeps) {
+                    pending.delete(gate.id);
+                    const result = {
+                        id: gate.id,
+                        ok: false,
+                        exit_code: null,
+                        duration_ms: 0,
+                        cached: false,
+                        stderr_tail: `blocked by failed dependency: ${gate.deps.filter((dep) => failed.has(dep)).join(', ')}`
+                    };
+                    failed.set(gate.id, result);
+                    appendReleaseGateJsonl(timeline, { event: 'blocked_by_failed_dependency', gate_id: gate.id, deps: gate.deps.filter((dep) => failed.has(dep)), at: new Date().toISOString() });
+                }
+                continue;
+            }
+            if (progressed)
+                continue;
+            const blocked = [...pending.keys()];
+            throw new Error(`release gate DAG stalled: ${blocked.join(', ')}`);
+        }
+        const result = await Promise.race([...running.values()].map((row) => row.promise));
+        running.delete(result.id);
+        sumGateMs += result.duration_ms;
+        if (result.ok) {
+            completed.set(result.id, result);
+            const gate = selected.find((row) => row.id === result.id);
+            if (gate?.cache.enabled && !input.noCache)
+                writeReleaseGateCacheHit(root, gate);
+        }
+        else {
+            failed.set(result.id, result);
+            if (input.failFast) {
+                for (const id of [...pending.keys()])
+                    pending.delete(id);
+            }
+        }
+        appendReleaseGateJsonl(timeline, { event: result.ok ? 'pass' : 'fail', gate_id: result.id, duration_ms: result.duration_ms, at: new Date().toISOString() });
+    }
+    const wallMs = Date.now() - started;
+    const failures = [...failed.values()].map((row) => ({ id: row.id, exit_code: row.exit_code, stderr_tail: row.stderr_tail }));
+    const result = {
+        schema: 'sks.release-gate-dag-run.v1',
+        ok: failures.length === 0,
+        run_id: runId,
+        selected_preset: preset,
+        total_gates: manifest.gates.length,
+        selected_gates: selected.length,
+        completed: completed.size,
+        failed: failed.size,
+        cached,
+        wall_ms: wallMs,
+        sum_gate_ms: sumGateMs,
+        cpu_time_saved_ms: Math.max(0, sumGateMs - wallMs),
+        parallelism_gain: wallMs > 0 ? Number((sumGateMs / wallMs).toFixed(2)) : 1,
+        critical_path_ms: estimateCriticalPath(selected, completed),
+        peak_running: peakRunning,
+        peak_resources: peakResources,
+        budget_snapshot: budget,
+        budget_summary: summarizeReleaseGateBudget(budget),
+        report_dir: reportDir,
+        failures
+    };
+    writeReleaseGateJson(path.join(reportDir, 'summary.json'), result);
+    return result;
+}
+function selectPreset(manifest, preset) {
+    return manifest.gates.filter((gate) => gate.preset.includes(preset));
+}
+function runGate(root, runId, reportRoot, gate) {
+    const started = Date.now();
+    const hermetic = createReleaseGateHermeticEnv({ root, runId, gate, reportRoot });
+    const stdoutFile = path.join(hermetic.report_dir, 'stdout.log');
+    const stderrFile = path.join(hermetic.report_dir, 'stderr.log');
+    const out = fs.createWriteStream(stdoutFile);
+    const err = fs.createWriteStream(stderrFile);
+    return new Promise((resolve) => {
+        const child = spawn(gate.command, { cwd: root, shell: true, env: hermetic.env, stdio: ['ignore', 'pipe', 'pipe'] });
+        const timer = setTimeout(() => child.kill('SIGTERM'), gate.timeout_ms);
+        child.stdout.pipe(out);
+        child.stderr.pipe(err);
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            out.end();
+            err.end();
+            const durationMs = Date.now() - started;
+            const stderrTail = tail(fs.existsSync(stderrFile) ? fs.readFileSync(stderrFile, 'utf8') : '');
+            const result = { id: gate.id, ok: code === 0, exit_code: code, duration_ms: durationMs, cached: false, stderr_tail: stderrTail };
+            writeReleaseGateJson(path.join(hermetic.report_dir, 'result.json'), { schema: 'sks.release-gate-result.v1', ...result, stdout_log: stdoutFile, stderr_log: stderrFile });
+            resolve(result);
+        });
+    });
+}
+function estimateCriticalPath(gates, completed) {
+    const byId = new Map(gates.map((gate) => [gate.id, gate]));
+    const memo = new Map();
+    const visit = (id) => {
+        if (memo.has(id))
+            return memo.get(id);
+        const gate = byId.get(id);
+        if (!gate)
+            return 0;
+        const own = completed.get(id)?.duration_ms || 0;
+        const dep = Math.max(0, ...gate.deps.map(visit));
+        memo.set(id, own + dep);
+        return own + dep;
+    };
+    return Math.max(0, ...gates.map((gate) => visit(gate.id)));
+}
+function tail(value, limit = 1200) {
+    return value.length > limit ? value.slice(-limit) : value;
+}
+//# sourceMappingURL=release-gate-dag.js.map

package/dist/core/release/release-gate-hermetic-env.js

@@ -0,0 +1,32 @@
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs';
+export function createReleaseGateHermeticEnv(input) {
+    const safeId = input.gate.id.replace(/[^a-zA-Z0-9._-]+/g, '-');
+    const tmpRoot = path.join(os.tmpdir(), 'sks-gate', input.runId, safeId);
+    const home = path.join(tmpRoot, 'home');
+    const codexHome = path.join(tmpRoot, 'codex-home');
+    const cacheHome = path.join(tmpRoot, 'xdg-cache');
+    const reportDir = path.join(input.reportRoot, safeId);
+    fs.mkdirSync(home, { recursive: true });
+    fs.mkdirSync(codexHome, { recursive: true });
+    fs.mkdirSync(cacheHome, { recursive: true });
+    fs.mkdirSync(reportDir, { recursive: true });
+    return {
+        tmp_dir: tmpRoot,
+        report_dir: reportDir,
+        env: {
+            ...process.env,
+            SKS_GATE_ID: input.gate.id,
+            SKS_GATE_RUN_ID: input.runId,
+            SKS_REPORT_DIR: reportDir,
+            SKS_TMP_DIR: tmpRoot,
+            HOME: input.gate.isolation.home === 'temp' ? home : process.env.HOME,
+            CODEX_HOME: input.gate.isolation.codex_home === 'temp' ? codexHome : process.env.CODEX_HOME,
+            XDG_CACHE_HOME: cacheHome,
+            SKS_DISABLE_REAL_MODEL_CALLS: input.gate.preset.includes('real-check') ? process.env.SKS_DISABLE_REAL_MODEL_CALLS || '0' : '1',
+            SKS_DISABLE_GLOBAL_CONFIG_MUTATION: '1'
+        }
+    };
+}
+//# sourceMappingURL=release-gate-hermetic-env.js.map

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

@@ -0,0 +1,62 @@
+export const RELEASE_GATE_NODE_SCHEMA = 'sks.release-gates.v2';
+export const RELEASE_GATE_RESOURCE_CLASSES = [
+    'cpu-light',
+    'cpu-heavy',
+    'io-light',
+    'io-heavy',
+    'git',
+    'git-worktree',
+    'zellij-real',
+    'local-llm-real',
+    'remote-model-real',
+    'python',
+    'network',
+    'global-config',
+    'publish',
+    'fs-read'
+];
+export function validateReleaseGateManifest(input) {
+    const errors = [];
+    if (input?.schema !== RELEASE_GATE_NODE_SCHEMA)
+        errors.push('schema_mismatch');
+    if (!Array.isArray(input?.gates))
+        errors.push('gates_missing');
+    const ids = new Set();
+    const resources = new Set(RELEASE_GATE_RESOURCE_CLASSES);
+    for (const gate of Array.isArray(input?.gates) ? input.gates : []) {
+        if (!gate?.id)
+            errors.push('gate_id_missing');
+        if (gate?.id && ids.has(gate.id))
+            errors.push(`gate_duplicate:${gate.id}`);
+        if (gate?.id)
+            ids.add(gate.id);
+        if (!gate?.command)
+            errors.push(`gate_command_missing:${gate?.id || 'unknown'}`);
+        if (!Array.isArray(gate?.deps))
+            errors.push(`gate_deps_missing:${gate?.id || 'unknown'}`);
+        if (!Array.isArray(gate?.resource) || !gate.resource.length)
+            errors.push(`gate_resource_missing:${gate?.id || 'unknown'}`);
+        for (const resource of Array.isArray(gate?.resource) ? gate.resource : []) {
+            if (!resources.has(resource))
+                errors.push(`gate_unknown_resource:${gate?.id || 'unknown'}:${resource}`);
+        }
+        if (gate?.side_effect !== 'hermetic' && gate?.side_effect !== 'real-env')
+            errors.push(`gate_side_effect_invalid:${gate?.id || 'unknown'}`);
+        if (!Number.isFinite(Number(gate?.timeout_ms)) || Number(gate.timeout_ms) <= 0)
+            errors.push(`gate_timeout_missing:${gate?.id || 'unknown'}`);
+        if (!gate?.cache || typeof gate.cache.enabled !== 'boolean' || !Array.isArray(gate.cache.inputs))
+            errors.push(`gate_cache_missing:${gate?.id || 'unknown'}`);
+        if (!gate?.isolation || gate.isolation.report_dir !== 'per-gate')
+            errors.push(`gate_isolation_missing:${gate?.id || 'unknown'}`);
+        if (!Array.isArray(gate?.preset))
+            errors.push(`gate_preset_missing:${gate?.id || 'unknown'}`);
+    }
+    for (const gate of Array.isArray(input?.gates) ? input.gates : []) {
+        for (const dep of Array.isArray(gate?.deps) ? gate.deps : []) {
+            if (!ids.has(dep))
+                errors.push(`gate_unknown_dep:${gate.id}:${dep}`);
+        }
+    }
+    return errors.length ? { ok: false, errors } : { ok: true, manifest: input, errors };
+}
+//# sourceMappingURL=release-gate-node.js.map

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

@@ -0,0 +1,11 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function writeReleaseGateJson(file, value) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`);
+}
+export function appendReleaseGateJsonl(file, value) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.appendFileSync(file, `${JSON.stringify(value)}\n`);
+}
+//# sourceMappingURL=release-gate-report.js.map

package/dist/core/release/release-gate-resource-governor.js

@@ -0,0 +1,54 @@
+import os from 'node:os';
+export function defaultReleaseGateBudget() {
+    const cores = Math.max(1, os.cpus().length || 1);
+    return {
+        'cpu-light': Math.min(32, cores * 4),
+        'cpu-heavy': Math.max(1, cores - 1),
+        'io-light': Math.min(64, cores * 8),
+        'io-heavy': Math.min(8, cores),
+        git: Math.min(8, cores),
+        'git-worktree': Math.min(6, cores),
+        python: Math.min(8, cores),
+        network: 8,
+        'zellij-real': 1,
+        'local-llm-real': Math.max(1, Number(process.env.SKS_LOCAL_LLM_MAX_PARALLEL || 1)),
+        'remote-model-real': 4,
+        'global-config': 1,
+        publish: 1,
+        'fs-read': Math.min(64, cores * 8)
+    };
+}
+export function summarizeReleaseGateBudget(budget = defaultReleaseGateBudget()) {
+    return Object.entries(budget)
+        .filter(([, value]) => Number(value) > 0)
+        .map(([resource, value]) => `${resource}=${value}`)
+        .join(' ');
+}
+export function countReleaseGateResources(running) {
+    return usedResources(running);
+}
+export function pickLaunchableReleaseGates(input) {
+    const budget = input.budget || defaultReleaseGateBudget();
+    const used = usedResources(input.running);
+    const launchable = [];
+    for (const gate of input.ready) {
+        if (fits(gate, used, budget)) {
+            launchable.push(gate);
+            for (const resource of gate.resource)
+                used[resource] = (used[resource] || 0) + 1;
+        }
+    }
+    return launchable;
+}
+function usedResources(running) {
+    const used = {};
+    for (const gate of running) {
+        for (const resource of gate.resource)
+            used[resource] = (used[resource] || 0) + 1;
+    }
+    return used;
+}
+function fits(gate, used, budget) {
+    return gate.resource.every((resource) => (used[resource] || 0) < budget[resource]);
+}
+//# sourceMappingURL=release-gate-resource-governor.js.map

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

@@ -0,0 +1,15 @@
+import { defaultReleaseGateBudget, pickLaunchableReleaseGates } from './release-gate-resource-governor.js';
+export function findReadyReleaseGateNodes(input) {
+    return [...input.pending.values()].filter((gate) => gate.deps.every((dep) => input.completed.has(dep)) && !gate.deps.some((dep) => input.failed.has(dep)));
+}
+export function findReleaseGatesBlockedByFailedDeps(input) {
+    return [...input.pending.values()].filter((gate) => gate.deps.some((dep) => input.failed.has(dep)));
+}
+export function pickReadyLaunchableReleaseGates(input) {
+    return pickLaunchableReleaseGates({
+        ready: input.ready,
+        running: input.running,
+        budget: defaultReleaseGateBudget()
+    });
+}
+//# sourceMappingURL=release-gate-scheduler.js.map

package/dist/core/version.js

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

package/dist/core/zellij/zellij-dashboard-pane.js

@@ -0,0 +1,71 @@
+import path from 'node:path';
+import { ensureDir, nowIso, writeJsonAtomic } from '../fsx.js';
+import { runZellij } from './zellij-command.js';
+import { extractZellijPaneIdFromOutput } from './zellij-lane-runtime.js';
+import { buildZellijDashboardSnapshot } from './zellij-dashboard-renderer.js';
+export const ZELLIJ_DASHBOARD_PANE_SCHEMA = 'sks.zellij-dashboard-pane.v1';
+export async function openZellijDashboardPane(input) {
+    const root = path.resolve(input.root);
+    const cwd = input.cwd || root;
+    const paneTitle = `dashboard · ${input.missionId}`;
+    const dashboardDir = path.join(root, '.sneakoscope', 'missions', input.missionId);
+    await ensureDir(dashboardDir);
+    const snapshot = buildZellijDashboardSnapshot({ ...(input.snapshot || {}), mission_id: input.missionId });
+    const snapshotPath = path.join(dashboardDir, 'zellij-dashboard-snapshot.json');
+    await writeJsonAtomic(snapshotPath, snapshot);
+    const watchScript = path.join(root, 'dist', 'scripts', 'zellij-dashboard-watch.js');
+    const command = `${shellQuote(process.execPath)} ${shellQuote(watchScript)} --snapshot ${shellQuote(snapshotPath)} --interval-ms 1000`;
+    const createSession = await runZellij(['attach', '--create-background', input.sessionName], { cwd, timeoutMs: 5000, optional: true });
+    const launch = await runZellij(['--session', input.sessionName, 'action', 'new-pane', '--direction', 'right', '--name', paneTitle, '--', 'sh', '-lc', command], {
+        cwd,
+        timeoutMs: 5000,
+        optional: false
+    });
+    const stdoutPaneId = launch.ok ? extractZellijPaneIdFromOutput(launch.stdout_tail) : null;
+    const listed = await runZellij(['--session', input.sessionName, 'action', 'list-panes', '--json', '--all'], { cwd, timeoutMs: 5000, optional: true });
+    const rows = parseRows(listed.stdout_tail);
+    const pane = stdoutPaneId ? null : rows.find((row) => String(row.title || row.name || '').includes(paneTitle));
+    const paneId = stdoutPaneId || pane?.pane_id || pane?.paneId || pane?.id || null;
+    const dump = await runZellij(['--session', input.sessionName, 'action', 'dump-screen'], { cwd, timeoutMs: 5000, optional: true });
+    const source = stdoutPaneId ? 'zellij_dashboard_new_pane_stdout' : paneId ? 'zellij_dashboard_list_panes' : 'zellij_dashboard_missing';
+    const blockers = [
+        ...(createSession.ok || /Session already exists/i.test(createSession.stderr_tail || '') ? [] : createSession.blockers.map((blocker) => `zellij_dashboard_session_${blocker}`)),
+        ...(launch.ok ? [] : launch.blockers.map((blocker) => `zellij_dashboard_pane_${blocker}`)),
+        ...(paneId ? [] : ['zellij_dashboard_pane_id_missing'])
+    ];
+    const record = {
+        schema: ZELLIJ_DASHBOARD_PANE_SCHEMA,
+        generated_at: nowIso(),
+        ok: blockers.length === 0,
+        mission_id: input.missionId,
+        session_name: input.sessionName,
+        pane_title: paneTitle,
+        pane_id: paneId == null ? null : String(paneId),
+        pane_id_source: source,
+        pane_kind: 'dashboard',
+        worker_pane: false,
+        command,
+        launch,
+        list_panes: listed,
+        dump_screen: dump,
+        snapshot,
+        blockers
+    };
+    await writeJsonAtomic(path.join(dashboardDir, 'zellij-dashboard-pane.json'), record);
+    return record;
+}
+function parseRows(text) {
+    if (!String(text || '').trim())
+        return [];
+    try {
+        const parsed = JSON.parse(String(text));
+        return Array.isArray(parsed) ? parsed : Array.isArray(parsed?.panes) ? parsed.panes : [];
+    }
+    catch {
+        return [];
+    }
+}
+function shellQuote(value) {
+    return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+//# sourceMappingURL=zellij-dashboard-pane.js.map

package/dist/core/zellij/zellij-dashboard-renderer.js

@@ -0,0 +1,42 @@
+import { nowIso } from '../fsx.js';
+export const ZELLIJ_DASHBOARD_RENDER_SCHEMA = 'sks.zellij-dashboard-render.v1';
+export function buildZellijDashboardSnapshot(input) {
+    return {
+        schema: ZELLIJ_DASHBOARD_RENDER_SCHEMA,
+        generated_at: nowIso(),
+        mission_id: input.mission_id,
+        mode: input.mode || 'naruto',
+        backend_counts: input.backend_counts || { 'codex-sdk': 1 },
+        placement_counts: input.placement_counts || { 'zellij-pane': 1 },
+        active_workers: Number(input.active_workers || 0),
+        visible_panes: Number(input.visible_panes || 0),
+        headless_workers: Number(input.headless_workers || 0),
+        queue_depth: Number(input.queue_depth || 0),
+        worktrees: input.worktrees || { active: 0, completed: 0, retained: 0 },
+        local_llm: input.local_llm || { tps: 0, queue: 0 },
+        gpt_final_status: input.gpt_final_status || 'not_started',
+        gate_progress: input.gate_progress || 'not_release',
+        latest_blockers: input.latest_blockers || []
+    };
+}
+export function renderZellijDashboardText(snapshot) {
+    const backendCounts = Object.entries(snapshot.backend_counts).map(([key, value]) => `${key}=${value}`).join(' ');
+    const placementCounts = Object.entries(snapshot.placement_counts).map(([key, value]) => `${key}=${value}`).join(' ');
+    return [
+        'SKS Dashboard',
+        `Mission: ${snapshot.mission_id}`,
+        `Mode: ${snapshot.mode}`,
+        `Backend counts: ${backendCounts || 'none'}`,
+        `Placement counts: ${placementCounts || 'none'}`,
+        `Active workers: ${snapshot.active_workers}`,
+        `Visible panes: ${snapshot.visible_panes}`,
+        `Headless workers: ${snapshot.headless_workers}`,
+        `Queue depth: ${snapshot.queue_depth}`,
+        `Worktrees active/completed/retained: ${snapshot.worktrees.active}/${snapshot.worktrees.completed}/${snapshot.worktrees.retained}`,
+        `Local LLM TPS / queue: ${snapshot.local_llm.tps}/${snapshot.local_llm.queue}`,
+        `GPT final status: ${snapshot.gpt_final_status}`,
+        `Gate progress: ${snapshot.gate_progress}`,
+        `Latest blockers: ${snapshot.latest_blockers.length ? snapshot.latest_blockers.join(', ') : 'none'}`
+    ].join('\n');
+}
+//# sourceMappingURL=zellij-dashboard-renderer.js.map

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

@@ -23,7 +23,7 @@ export function buildWorkerPaneArtifact(input) {
     const paneIdSource = input.paneIdSource || 'zellij_worker_pane_launch_failed';
     const blockers = input.blockers || [];
     const providerContext = normalizePaneProviderContext(input.providerContext, input.serviceTier);
-    const paneTitle = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier, input.backend, input.status || input.statusLabel, input.worktree || null);
+    const paneTitle = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier, input.backend, input.statusLabel || input.status, input.worktree || null);
     return {
         schema: ZELLIJ_WORKER_PANE_SCHEMA,
         generated_at: now,
@@ -79,11 +79,12 @@ export async function openWorkerPane(input) {
     const workerDir = path.join(root, input.workerArtifactDir);
     await ensureDir(workerDir);
     await appendWorkerPaneEvent(root, 'session_launch_started', input, {});
-    const createSession = await runZellij(['attach', '--create-background', input.sessionName], {
+    const createSessionRaw = await runZellij(['attach', '--create-background', input.sessionName], {
         cwd,
         timeoutMs: 5000,
         optional: false
     });
+    const createSession = normalizeExistingZellijSession(input.sessionName, createSessionRaw);
     const paneName = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier, input.backend, input.statusLabel || 'running', input.worktree || null);
     let launch = createSession.ok
         ? await runZellij(['--session', input.sessionName, 'action', 'new-pane', '--direction', 'right', '--name', paneName, '--', 'sh', '-lc', input.workerCommand], {
@@ -107,6 +108,7 @@ export async function openWorkerPane(input) {
     const stdoutPaneId = launch?.ok ? extractZellijPaneIdFromOutput(launch.stdout_tail) : null;
     const reconciledPane = stdoutPaneId ? null : launch?.ok ? await reconcileZellijWorkerPaneId(input.sessionName, paneName, path.join(root, input.resultPath), cwd) : null;
     const paneId = stdoutPaneId || reconciledPane?.pane_id || null;
+    const renamePane = paneId ? await renameZellijPaneById(input.sessionName, paneId, paneName, cwd) : null;
     const paneIdSource = stdoutPaneId
         ? 'zellij_worker_new_pane_stdout'
         : reconciledPane?.pane_id
@@ -125,7 +127,7 @@ export async function openWorkerPane(input) {
         paneIdSource,
         createSession,
         launch,
-        paneReconciliation: reconciledPane,
+        paneReconciliation: { ...(reconciledPane || {}), rename_pane: renamePane },
         directionApplied,
         status: blockers.length ? 'failed' : 'running',
         providerContext,
@@ -262,6 +264,11 @@ async function reconcileZellijWorkerPaneId(sessionName, paneName, resultPath, cw
         timeoutMs: 5000,
         optional: true
     });
+    const screen = await runZellij(['--session', sessionName, 'action', 'dump-screen'], {
+        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 || '');
@@ -280,6 +287,7 @@ async function reconcileZellijWorkerPaneId(sessionName, paneName, resultPath, cw
         pane_id: paneId == null ? null : String(paneId),
         listed_count: rows.length,
         command: listed,
+        dump_screen: screen,
         blockers: paneId == null ? ['zellij_worker_pane_id_not_reconciled'] : []
     };
 }
@@ -330,4 +338,56 @@ function parsePaneRows(text) {
         return [];
     }
 }
+async function renameZellijPaneById(sessionName, paneId, paneName, cwd) {
+    const numeric = Number.parseInt(paneId.replace(/^terminal_/, ''), 10);
+    const numericCandidates = Number.isFinite(numeric)
+        ? [numeric, numeric + 1, numeric - 1].filter((value) => value >= 0).map(String)
+        : [];
+    const candidates = [...new Set([paneId, paneId.replace(/^terminal_/, ''), ...numericCandidates].filter(Boolean))];
+    let last = null;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        if (attempt > 0)
+            await sleep(200 * attempt);
+        for (const candidate of candidates) {
+            last = await runZellij(['--session', sessionName, 'action', 'rename-pane', '--pane-id', candidate, paneName], {
+                cwd,
+                timeoutMs: 5000,
+                optional: true
+            });
+            if (last.ok)
+                return last;
+            const focus = await runZellij(['--session', sessionName, 'action', 'focus-pane-id', candidate], {
+                cwd,
+                timeoutMs: 5000,
+                optional: true
+            });
+            if (focus.ok) {
+                last = await runZellij(['--session', sessionName, 'action', 'rename-pane', paneName], {
+                    cwd,
+                    timeoutMs: 5000,
+                    optional: true
+                });
+                if (last.ok)
+                    return last;
+            }
+        }
+    }
+    return last;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function normalizeExistingZellijSession(sessionName, result) {
+    if (result.ok)
+        return result;
+    if (/Session already exists/i.test(result.stderr_tail || '')) {
+        return {
+            ...result,
+            ok: true,
+            blockers: [],
+            warnings: [...result.warnings, `zellij_session_already_exists:${sessionName}`]
+        };
+    }
+    return result;
+}
 //# sourceMappingURL=zellij-worker-pane-manager.js.map

package/dist/scripts/git-worktree-diff-envelope-check.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const envelopeMod = await importDist('core/git/git-worktree-patch-envelope.js');
+const schemaMod = await importDist('core/agents/agent-patch-schema.js');
+const envelope = envelopeMod.buildGitWorktreePatchEnvelope({
+    diff: { schema: 'sks.git-worktree-diff.v1', mission_id: 'M-env', worker_id: 'worker-1', main_repo_root: '.', worktree_path: '.', branch: null, base_head: null, worktree_head: null, changed_files: ['a.txt', 'b.txt'], diff_bytes: 12, diff: 'diff --git a/a.txt b/a.txt\n', clean: false },
+    agentId: 'agent-1',
+    sessionId: 'session-1',
+    slotId: 'slot-001',
+    generationIndex: 1
+});
+const validation = schemaMod.validateAgentPatchEnvelope(schemaMod.normalizeAgentPatchEnvelope(envelope));
+assertGate(envelope.operations.length === 1 && envelope.operations[0].op === 'git_apply_patch', 'git worktree envelope must use one git_apply_patch operation', envelope);
+assertGate(validation.ok === true, 'git_apply_patch envelope must validate', validation);
+emitGate('git:worktree-diff-envelope', { operations: envelope.operations.length, op: envelope.operations[0].op });
+//# sourceMappingURL=git-worktree-diff-envelope-check.js.map

package/dist/scripts/git-worktree-dirty-lock-check.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+import { makeGitFixture } from './lib/git-worktree-fixture.js';
+const managerMod = await importDist('core/git/git-worktree-manager.js');
+const cleanupMod = await importDist('core/git/git-worktree-cleanup.js');
+const repo = makeGitFixture('dirty-lock');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-lock-'));
+const allocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-lock', workerId: 'worker-1', slotId: 'slot-001' });
+fs.writeFileSync(path.join(allocation.worktree_path, 'a.txt'), 'dirty\n');
+const cleanup = await cleanupMod.cleanupGitWorktree({ repoRoot: repo, worktreePath: allocation.worktree_path, branch: allocation.branch });
+assertGate(cleanup.action === 'retained_dirty' && cleanup.git_locked === true, 'dirty retained worktree must be git locked', cleanup);
+emitGate('git:worktree-dirty-lock', { git_locked: cleanup.git_locked, unlock_command: cleanup.unlock_command });
+//# sourceMappingURL=git-worktree-dirty-lock-check.js.map

package/dist/scripts/git-worktree-dirty-main-detection-check.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+import { makeGitFixture } from './lib/git-worktree-fixture.js';
+const detectionMod = await importDist('core/git/git-repo-detection.js');
+const repo = makeGitFixture('dirty-main-detection');
+fs.writeFileSync(path.join(repo, 'dirty.txt'), 'dirty\n');
+const detection = await detectionMod.detectGitRepo(repo);
+assertGate(detection.main_worktree_dirty === true, 'dirty main worktree must be detected', detection);
+assertGate(String(detection.status_porcelain).includes('dirty.txt'), 'status_porcelain must include dirty file', detection);
+emitGate('git:worktree-dirty-main-detection', { dirty: detection.main_worktree_dirty });
+//# sourceMappingURL=git-worktree-dirty-main-detection-check.js.map