sneakoscope 2.0.8 → 2.0.10

package/dist/core/naruto/naruto-real-worker-runtime.js

@@ -0,0 +1,121 @@
+import fs from 'node:fs';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ensureDir, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+import { allocateWorkerWorktree } from '../git/git-worktree-manager.js';
+import { cleanupGitWorktree } from '../git/git-worktree-cleanup.js';
+export async function spawnActualNarutoWorker(input) {
+    const workerDir = path.join(input.root, '.sneakoscope', 'missions', input.missionId, 'agents', 'naruto-real-workers', input.item.id);
+    await ensureDir(workerDir);
+    let worktree = null;
+    if (input.worktreePolicy?.mode === 'git-worktree' && input.item.write_allowed === true) {
+        const allocation = await allocateWorkerWorktree({
+            repoRoot: input.worktreePolicy.main_repo_root || input.root,
+            missionId: input.missionId,
+            workerId: input.item.id,
+            slotId: input.item.id.replace(/[^A-Za-z0-9_-]/g, '-'),
+            generationIndex: 1
+        }).catch((err) => ({ ok: false, blockers: [`git_worktree_allocate_exception:${err?.message || String(err)}`] }));
+        await writeJsonAtomic(path.join(workerDir, 'git-worktree-allocation.json'), allocation);
+        if (allocation.ok)
+            worktree = allocation;
+    }
+    const resultPath = path.join(workerDir, 'worker-result.json');
+    const heartbeatPath = path.join(workerDir, 'worker-heartbeat.jsonl');
+    const intakePath = path.join(workerDir, 'worker-intake.json');
+    await writeJsonAtomic(intakePath, {
+        schema: 'sks.naruto-actual-worker-intake.v1',
+        generated_at: nowIso(),
+        mission_id: input.missionId,
+        item: input.item,
+        placement: input.placement,
+        backend: input.backend,
+        result_path: resultPath,
+        heartbeat_path: heartbeatPath,
+        worktree_path: worktree?.worktree_path || null,
+        zellij_session_name: input.zellijSessionName || null,
+        visible_pane_cap: input.visiblePaneCap
+    });
+    const child = spawn(process.execPath, [actualWorkerEntrypoint(), intakePath], {
+        cwd: worktree?.worktree_path || input.root,
+        stdio: ['ignore', 'ignore', 'ignore']
+    });
+    const exit = waitForExit(child, 30000);
+    return {
+        id: input.item.id,
+        item: input.item,
+        placement: input.placement,
+        started_at: Date.now(),
+        pid: child.pid || null,
+        child,
+        worker_artifact_dir: workerDir,
+        result_path: resultPath,
+        heartbeat_path: heartbeatPath,
+        worktree,
+        exit
+    };
+}
+export async function collectActualNarutoWorker(handle) {
+    const exit = await handle.exit;
+    const result = await readJson(handle.result_path, null).catch(() => null);
+    const blockers = [
+        ...(exit.code === 0 ? [] : [`naruto_actual_worker_exit_${exit.code ?? exit.signal ?? 'unknown'}`]),
+        ...(result?.ok === false ? result.blockers || ['naruto_actual_worker_result_not_ok'] : []),
+        ...(result ? [] : ['naruto_actual_worker_result_missing'])
+    ];
+    if (handle.worktree?.worktree_path) {
+        const cleanup = await cleanupGitWorktree({
+            repoRoot: handle.worktree.main_repo_root || handle.worktree.repo_root || handle.worktree.repoRoot || '',
+            worktreePath: handle.worktree.worktree_path,
+            branch: handle.worktree.branch,
+            deleteBranch: true
+        }).catch((err) => ({ ok: false, blockers: [`git_worktree_cleanup_exception:${err?.message || String(err)}`] }));
+        await writeJsonAtomic(path.join(handle.worker_artifact_dir, 'git-worktree-cleanup.json'), cleanup);
+        blockers.push(...(cleanup.blockers || []));
+    }
+    return {
+        id: handle.id,
+        ok: blockers.length === 0,
+        item: handle.item,
+        placement: handle.placement,
+        completed_at: Date.now(),
+        pid: handle.pid,
+        worker_artifact_dir: handle.worker_artifact_dir,
+        blockers
+    };
+}
+function actualWorkerEntrypoint() {
+    return fileURLToPath(new URL('./naruto-real-worker-child.js', import.meta.url));
+}
+function waitForExit(child, timeoutMs) {
+    return new Promise((resolve) => {
+        let settled = false;
+        let killTimer = null;
+        const finish = (code, signal) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (killTimer)
+                clearTimeout(killTimer);
+            resolve({ code, signal });
+        };
+        const timer = setTimeout(() => {
+            if (!child.killed)
+                child.kill();
+            killTimer = setTimeout(() => {
+                if (!settled)
+                    child.kill('SIGKILL');
+                finish(null, 'SIGKILL');
+            }, 5000);
+        }, Math.max(1000, timeoutMs));
+        child.on('close', (code, signal) => {
+            finish(code, signal);
+        });
+        child.on('error', () => {
+            finish(1, null);
+        });
+    });
+}
+//# sourceMappingURL=naruto-real-worker-runtime.js.map

package/dist/core/naruto/naruto-work-graph.js

@@ -28,7 +28,8 @@ export function buildNarutoWorkGraph(input = {}) {
     const requestedClones = normalizePositiveInt(input.requestedClones, 12);
     const readonly = input.readonly === true;
     const writeCapable = input.writeCapable !== false && !readonly;
-    const totalWorkItems = Math.max(requestedClones, normalizePositiveInt(input.totalWorkItems, requestedClones));
+    const minimumFanout = writeCapable ? requestedClones * 2 : requestedClones;
+    const totalWorkItems = Math.max(minimumFanout, normalizePositiveInt(input.totalWorkItems, minimumFanout));
     const kindCycle = writeCapable ? WRITE_CAPABLE_KIND_CYCLE : READONLY_KIND_CYCLE;
     const basePath = normalizeNarutoPath(input.leaseBasePath || '.sneakoscope/naruto/patch-envelopes');
     const targetPaths = normalizePaths(input.targetPaths || []);

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

@@ -19,14 +19,59 @@ export function releaseGateCacheKey(root, gate) {
     hashFileIfPresent(hash, path.join(root, 'package.json'));
     hashFileIfPresent(hash, path.join(root, 'dist', 'build-manifest.json'));
     for (const input of gate.cache.inputs) {
-        const file = path.join(root, input);
-        if (fs.existsSync(file) && fs.statSync(file).isFile())
+        const expanded = expandGlob(root, input);
+        hash.update(`input:${input}`);
+        if (!expanded.length) {
+            hash.update(`missing_or_empty:${input}`);
+            continue;
+        }
+        for (const file of expanded) {
+            hash.update(path.relative(root, file));
             hashFileIfPresent(hash, file);
-        else
-            hash.update(input);
+        }
     }
     return hash.digest('hex');
 }
+export function expandGlob(root, input) {
+    const absolute = path.join(root, input);
+    if (!/[*!?[\]{}]/.test(input)) {
+        if (!fs.existsSync(absolute))
+            return [];
+        const stat = fs.statSync(absolute);
+        if (stat.isDirectory())
+            return hashDirectoryRecursive(absolute);
+        return stat.isFile() ? [absolute] : [];
+    }
+    if (input.endsWith('/**')) {
+        const dir = path.join(root, input.slice(0, -3));
+        return fs.existsSync(dir) && fs.statSync(dir).isDirectory() ? hashDirectoryRecursive(dir) : [];
+    }
+    const firstWildcard = input.search(/[*!?[\]{}]/);
+    const prefix = input.slice(0, firstWildcard);
+    const base = path.join(root, prefix.includes('/') ? prefix.slice(0, prefix.lastIndexOf('/')) : '');
+    if (!fs.existsSync(base))
+        return [];
+    const re = globToRegExp(input);
+    return hashDirectoryRecursive(base).filter((file) => re.test(path.relative(root, file)));
+}
+export function hashDirectoryRecursive(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    const out = [];
+    const stack = [dir];
+    while (stack.length) {
+        const current = stack.pop();
+        for (const name of fs.readdirSync(current).sort()) {
+            const file = path.join(current, name);
+            const stat = fs.statSync(file);
+            if (stat.isDirectory())
+                stack.push(file);
+            else if (stat.isFile())
+                out.push(file);
+        }
+    }
+    return out.sort();
+}
 export function readReleaseGateCacheHit(root, gate) {
     try {
         const parsed = JSON.parse(fs.readFileSync(releaseGateCacheFile(root), 'utf8'));
@@ -60,4 +105,13 @@ function hashFileIfPresent(hash, file) {
     if (fs.existsSync(file) && fs.statSync(file).isFile())
         hash.update(fs.readFileSync(file));
 }
+function globToRegExp(input) {
+    const escaped = input
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*/g, '\u0000')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '[^/]')
+        .replace(/\u0000/g, '.*');
+    return new RegExp(`^${escaped}$`);
+}
 //# sourceMappingURL=release-gate-cache-v2.js.map

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

@@ -35,6 +35,39 @@ export async function runReleaseGateDag(input) {
     let cached = 0;
     let sumGateMs = 0;
     let peakRunning = 0;
+    const writeSummarySnapshot = (finished = false) => {
+        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 snapshot = {
+            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
+        };
+        if (!finished) {
+            snapshot.in_progress = true;
+            snapshot.pending = pending.size;
+            snapshot.running = running.size;
+        }
+        writeReleaseGateJson(path.join(reportDir, 'summary.json'), snapshot);
+        return snapshot;
+    };
     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 })) });
     }
@@ -51,6 +84,7 @@ export async function runReleaseGateDag(input) {
                 cached += 1;
                 progressed = true;
                 appendReleaseGateJsonl(timeline, { event: 'cache_hit', gate_id: gate.id, at: new Date().toISOString() });
+                writeSummarySnapshot(false);
                 continue;
             }
             appendReleaseGateJsonl(timeline, { event: 'start', gate_id: gate.id, resource: gate.resource, at: new Date().toISOString() });
@@ -102,32 +136,9 @@ export async function runReleaseGateDag(input) {
             }
         }
         appendReleaseGateJsonl(timeline, { event: result.ok ? 'pass' : 'fail', gate_id: result.id, duration_ms: result.duration_ms, at: new Date().toISOString() });
+        writeSummarySnapshot(false);
     }
-    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);
+    const result = writeSummarySnapshot(true);
     return result;
 }
 function selectPreset(manifest, preset) {

package/dist/core/version.js

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

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

@@ -6,6 +6,10 @@ export function buildZellijDashboardSnapshot(input) {
         generated_at: nowIso(),
         mission_id: input.mission_id,
         mode: input.mode || 'naruto',
+        route: input.route || input.mode || '$Naruto',
+        provider: input.provider || 'unknown',
+        service_tier: input.service_tier || 'fast',
+        backpressure: input.backpressure || 'normal',
         backend_counts: input.backend_counts || { 'codex-sdk': 1 },
         placement_counts: input.placement_counts || { 'zellij-pane': 1 },
         active_workers: Number(input.active_workers || 0),
@@ -16,6 +20,15 @@ export function buildZellijDashboardSnapshot(input) {
         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',
+        patch_verify: input.patch_verify || {
+            patches: 0,
+            gpt_approved: 0,
+            conflicts: 0,
+            verification_running: 0,
+            verification_passed: 0,
+            verification_failed: 0
+        },
+        workers: input.workers || [],
         latest_blockers: input.latest_blockers || []
     };
 }
@@ -25,18 +38,21 @@ export function renderZellijDashboardText(snapshot) {
     return [
         'SKS Dashboard',
         `Mission: ${snapshot.mission_id}`,
-        `Mode: ${snapshot.mode}`,
+        `Route / mode: ${snapshot.route} / ${snapshot.mode} / ${snapshot.service_tier}`,
+        `Provider: ${snapshot.provider}`,
         `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}`,
+        `Active / visible / headless / queued: ${snapshot.active_workers}/${snapshot.visible_panes}/${snapshot.headless_workers}/${snapshot.queue_depth}`,
+        `Backpressure: ${snapshot.backpressure}`,
         `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'}`
+        `Patch / verify: patches ${snapshot.patch_verify.patches} · approved ${snapshot.patch_verify.gpt_approved} · conflicts ${snapshot.patch_verify.conflicts} · verify ${snapshot.patch_verify.verification_running}/${snapshot.patch_verify.verification_passed}/${snapshot.patch_verify.verification_failed}`,
+        'Workers:',
+        ...(snapshot.workers.length ? snapshot.workers.slice(0, 12).map((worker) => `${worker.slot_id} gen-${worker.generation_index} ${worker.role} ${worker.backend}/${worker.provider}/${worker.service_tier} WT:${worker.worktree_id || '-'} ${worker.status} ${worker.current_file || ''} ${worker.latest_heartbeat || ''}`) : ['none']),
+        `Latest blockers: ${snapshot.latest_blockers.length ? snapshot.latest_blockers.join(', ') : 'none'}`,
+        'Controls: q detach | /stop selected | /focus slot | /logs'
     ].join('\n');
 }
 //# sourceMappingURL=zellij-dashboard-renderer.js.map

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

@@ -19,7 +19,7 @@ export async function launchZellijLayout(opts = {}) {
         ledgerRoot,
         cwd: opts.cwd || root,
         kind: opts.kind || 'agent',
-        slotCount: opts.slotCount || 1,
+        slotCount: opts.slotCount ?? 1,
         title: `SKS ${opts.kind || 'agent'} ${missionId}`,
         codexArgs: opts.codexArgs || [],
         launchEnv: opts.launchEnv || {}
@@ -124,7 +124,7 @@ export async function launchMadZellijUi(args = [], opts = {}) {
     const launchOpts = {
         ...opts,
         kind: 'mad',
-        slotCount: opts.slotCount || 1
+        slotCount: opts.slotCount ?? 1
     };
     const resolvedSession = session || opts.session;
     if (resolvedSession)
@@ -135,7 +135,7 @@ export async function launchTeamZellijView(opts = {}) {
     return launchZellijLayout({
         ...opts,
         kind: 'team',
-        slotCount: opts.slotCount || 5
+        slotCount: opts.slotCount ?? 5
     });
 }
 /**

package/dist/core/zellij/zellij-layout-builder.js

@@ -3,7 +3,7 @@ import { ensureDir, nowIso, packageRoot, writeTextAtomic } from '../fsx.js';
 import { writeZellijLaneRuntimeManifest } from './zellij-lane-runtime.js';
 export const ZELLIJ_LAYOUT_SCHEMA = 'sks.zellij-layout.v1';
 export function buildZellijLayoutKdl(input) {
-    const slotCount = Math.max(1, Number(input.slotCount || 1));
+    const slotCount = Math.max(0, Number(input.slotCount ?? 1));
     const sessionName = input.sessionName || `sks-${input.missionId}`;
     const cwd = path.resolve(input.cwd || process.cwd());
     const ledgerRoot = path.resolve(input.ledgerRoot);

package/dist/core/zellij/zellij-right-column-layout-proof.js

@@ -0,0 +1,42 @@
+export function evaluateZellijRightColumnGeometry(input) {
+    const tolerance = Math.max(0, Number(input.tolerance ?? 2));
+    const main = input.panes.find((pane) => pane.role === 'main') || null;
+    const dashboard = input.panes.find((pane) => pane.role === 'dashboard') || null;
+    const workers = input.panes.filter((pane) => pane.role === 'worker');
+    const workerGeometries = workers.map((pane) => pane.geometry).filter(Boolean);
+    const baseX = workerGeometries[0]?.x;
+    const sameRightX = baseX == null ? null : workerGeometries.every((geometry) => geometry.x != null && Math.abs(geometry.x - baseX) <= tolerance);
+    const rightOfMain = !main?.geometry ? null : workerGeometries.every((geometry) => {
+        if (geometry.x == null || main.geometry?.x == null || main.geometry?.width == null)
+            return false;
+        return geometry.x >= main.geometry.x + main.geometry.width - tolerance;
+    });
+    const increasingY = workerGeometries.every((geometry, index) => {
+        if (index === 0)
+            return true;
+        const previous = workerGeometries[index - 1];
+        return geometry.y != null && previous?.y != null && geometry.y > previous.y;
+    });
+    const visibleCapOk = workers.length <= Math.max(0, Math.floor(Number(input.visiblePaneCap || 0)));
+    const blockers = [
+        ...(!main ? ['right_column_main_pane_missing'] : []),
+        ...(!dashboard ? ['right_column_dashboard_missing'] : []),
+        ...(sameRightX === false ? ['right_column_worker_x_range_mismatch'] : []),
+        ...(rightOfMain === false ? ['right_column_workers_not_right_of_main'] : []),
+        ...(increasingY === false ? ['right_column_workers_not_stacked_down'] : []),
+        ...(visibleCapOk ? [] : ['right_column_visible_cap_exceeded'])
+    ];
+    return {
+        schema: 'sks.zellij-right-column-layout-proof.v1',
+        ok: blockers.length === 0,
+        main_pane_id: main?.pane_id || null,
+        dashboard_pane_id: dashboard?.pane_id || null,
+        worker_pane_ids: workers.map((pane) => pane.pane_id),
+        same_right_x: sameRightX,
+        right_of_main: rightOfMain,
+        increasing_y: increasingY,
+        visible_cap_ok: visibleCapOk,
+        blockers
+    };
+}
+//# sourceMappingURL=zellij-right-column-layout-proof.js.map