sneakoscope 2.0.5 → 2.0.7

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

@@ -9,10 +9,11 @@ export const ZELLIJ_WORKER_PANE_EVENT_SCHEMA = 'sks.zellij-worker-pane-event.v1'
 export function buildWorkerPaneName(slotId, generationIndex) {
     return `${slotId}/gen-${Math.max(1, Math.floor(Number(generationIndex) || 1))}`;
 }
-export function buildWorkerPaneTitle(slotId, generationIndex, context, serviceTier, backend, status) {
+export function buildWorkerPaneTitle(slotId, generationIndex, context, serviceTier, backend, status, worktree) {
     const base = buildWorkerPaneName(slotId, generationIndex);
     const normalized = normalizePaneProviderContext(context, serviceTier);
-    return `${base} · ${backend || 'codex-sdk'} · ${providerPaneLabel(normalized)} · ${status || 'launching'}`;
+    const wt = worktree ? ` · WT:${worktree.id} · branch:${worktree.branch}` : '';
+    return `${base}${wt} · ${backend || 'codex-sdk'} · ${providerPaneLabel(normalized)} · ${status || 'launching'}`;
 }
 export function isRealZellijWorkerPaneIdSource(value) {
     return value === 'zellij_worker_new_pane_stdout' || value === 'zellij_worker_list_panes';
@@ -22,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);
+    const paneTitle = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier, input.backend, input.status || input.statusLabel, input.worktree || null);
     return {
         schema: ZELLIJ_WORKER_PANE_SCHEMA,
         generated_at: now,
@@ -42,6 +43,7 @@ export function buildWorkerPaneArtifact(input) {
         provider: providerContext.provider,
         service_tier: providerContext.service_tier,
         provider_context: providerContext,
+        worktree: input.worktree || null,
         worker_artifact_dir: input.workerArtifactDir,
         worker_result_path: input.resultPath,
         heartbeat_path: input.heartbeatPath,
@@ -82,7 +84,7 @@ export async function openWorkerPane(input) {
         timeoutMs: 5000,
         optional: false
     });
-    const paneName = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier, input.backend, input.statusLabel || 'running');
+    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], {
             cwd,

package/dist/scripts/git-worktree-cache-performance-check.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const policyMod = await importDist('core/git/git-worktree-cache-policy.js');
+const now = Date.now();
+const entries = Array.from({ length: 1000 }, (_, index) => ({
+    path: `/tmp/wt-${index}`,
+    updated_at_ms: now - index * 60000,
+    bytes: 1024 * (index + 1),
+    dirty: index % 137 === 0
+}));
+const start = Date.now();
+const plan = policyMod.planGitWorktreeCachePolicy({ entries, nowMs: now, maxEntries: 120, maxBytes: 40 * 1024 * 1024, ttlMs: 2 * 60 * 60 * 1000 });
+const elapsed = Date.now() - start;
+assertGate(plan.ok === true, 'cache policy plan must pass', plan);
+assertGate(plan.keep.length <= 120 || plan.dirty_retained.length > 0, 'cache policy must bound retained clean entries', plan);
+assertGate(plan.dirty_retained.length > 0, 'dirty entries must be retained by cache policy', plan);
+assertGate(elapsed < 250, 'cache policy must stay fast on 1000 entries', { elapsed });
+emitGate('git:worktree-cache-performance', {
+    elapsed_ms: elapsed,
+    keep: plan.keep.length,
+    prune: plan.prune.length,
+    dirty_retained: plan.dirty_retained.length
+});
+//# sourceMappingURL=git-worktree-cache-performance-check.js.map

package/dist/scripts/git-worktree-capability-check.js

@@ -0,0 +1,27 @@
+#!/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, makeNonGitFixture } from './lib/git-worktree-fixture.js';
+const capabilityMod = await importDist('core/git/git-worktree-capability.js');
+const nonGit = makeNonGitFixture('worktree-capability-non-git');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-capability-'));
+delete process.env.SKS_ALLOW_IN_REPO_WORKTREES;
+const nonGitCapability = await capabilityMod.evaluateGitWorktreeCapability({ root: nonGit, missionId: 'M-non-git' });
+assertGate(nonGitCapability.mode === 'patch-envelope-only', 'non-Git projects must degrade to patch-envelope-only', nonGitCapability);
+assertGate(nonGitCapability.worktree_probe_attempted === false, 'non-Git projects must not probe git worktree', nonGitCapability);
+const repo = makeGitFixture('worktree-capability-git');
+const gitCapability = await capabilityMod.evaluateGitWorktreeCapability({ root: repo, missionId: 'M-git' });
+assertGate(gitCapability.ok === true && gitCapability.mode === 'git-worktree', 'Git fixture must support worktree mode', gitCapability);
+assertGate(gitCapability.root_resolution?.in_repo === false, 'default worktree root must be outside main repo', gitCapability.root_resolution);
+process.env.SKS_WORKTREE_ROOT = path.join(repo, '.sneakoscope', 'worktrees');
+const blocked = await capabilityMod.evaluateGitWorktreeCapability({ root: repo, missionId: 'M-in-repo' });
+assertGate(blocked.ok === false && blocked.blockers.includes('git_worktree_root_inside_repo_blocked'), 'in-repo worktree root must be blocked by default', blocked);
+emitGate('git:worktree-capability', {
+    non_git_mode: nonGitCapability.mode,
+    git_mode: gitCapability.mode,
+    in_repo_blocked: true
+});
+//# sourceMappingURL=git-worktree-capability-check.js.map

package/dist/scripts/git-worktree-cleanup-check.js

@@ -0,0 +1,27 @@
+#!/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('worktree-cleanup');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-cleanup-'));
+const cleanAllocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-cleanup', workerId: 'clean', slotId: 'slot-001' });
+const clean = await cleanupMod.cleanupGitWorktree({ repoRoot: repo, worktreePath: cleanAllocation.worktree_path, branch: cleanAllocation.branch, deleteBranch: true });
+assertGate(clean.ok === true && clean.action === 'removed', 'clean worktree must be removed by cleanup manager', clean);
+assertGate(!fs.existsSync(cleanAllocation.worktree_path), 'removed clean worktree path should be gone');
+const dirtyAllocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-cleanup', workerId: 'dirty', slotId: 'slot-002' });
+fs.writeFileSync(path.join(dirtyAllocation.worktree_path, 'a.txt'), 'dirty\n');
+const dirty = await cleanupMod.cleanupGitWorktree({ repoRoot: repo, worktreePath: dirtyAllocation.worktree_path, branch: dirtyAllocation.branch, deleteBranch: true });
+assertGate(dirty.ok === true && dirty.action === 'retained_dirty', 'dirty worktree must be retained', dirty);
+assertGate(fs.existsSync(dirtyAllocation.worktree_path), 'dirty worktree path must still exist');
+assertGate(dirty.retention_lock_path && fs.existsSync(dirty.retention_lock_path), 'dirty retention lock must be written outside the retained worktree', dirty);
+emitGate('git:worktree-cleanup', {
+    clean_action: clean.action,
+    dirty_action: dirty.action,
+    retention_lock_path: dirty.retention_lock_path
+});
+//# sourceMappingURL=git-worktree-cleanup-check.js.map

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

@@ -0,0 +1,43 @@
+#!/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, run } from './lib/git-worktree-fixture.js';
+const managerMod = await importDist('core/git/git-worktree-manager.js');
+const diffMod = await importDist('core/git/git-worktree-diff.js');
+const envelopeMod = await importDist('core/git/git-worktree-patch-envelope.js');
+const schemaMod = await importDist('core/agents/agent-patch-schema.js');
+const cleanupMod = await importDist('core/git/git-worktree-cleanup.js');
+const repo = makeGitFixture('worktree-diff');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-diff-'));
+const allocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-diff', workerId: 'worker-1', slotId: 'slot-001' });
+fs.writeFileSync(path.join(allocation.worktree_path, 'a.txt'), 'alpha\nchanged\n');
+const diff = await diffMod.exportGitWorktreeDiff({
+    mainRepoRoot: repo,
+    worktreePath: allocation.worktree_path,
+    missionId: 'M-diff',
+    workerId: 'worker-1'
+});
+const envelope = envelopeMod.buildGitWorktreePatchEnvelope({
+    diff,
+    agentId: 'agent-1',
+    sessionId: 'session-1',
+    slotId: 'slot-001',
+    generationIndex: 1
+});
+const validation = schemaMod.validateAgentPatchEnvelope(schemaMod.normalizeAgentPatchEnvelope(envelope));
+assertGate(diff.ok === true && diff.clean === false, 'diff export must detect changed worktree', diff);
+assertGate(diff.changed_files.includes('a.txt'), 'diff export must include changed file', diff);
+assertGate(/index [0-9a-f]{40}\.\.[0-9a-f]{40}/.test(diff.diff), 'diff export must use full-index diff hashes', { diff: diff.diff });
+assertGate(envelope.source === 'git-worktree-diff' && validation.ok === true, 'git worktree diff patch envelope must validate', { envelope, validation });
+assertGate(run('git', ['status', '--porcelain=v1'], repo).trim() === '', 'main repo must stay clean after diff export');
+run('git', ['checkout', '--', 'a.txt'], allocation.worktree_path);
+await cleanupMod.cleanupGitWorktree({ repoRoot: repo, worktreePath: allocation.worktree_path, branch: allocation.branch, deleteBranch: true });
+emitGate('git:worktree-diff-export', {
+    changed_files: diff.changed_files,
+    diff_bytes: diff.diff_bytes,
+    envelope_source: envelope.source
+});
+//# sourceMappingURL=git-worktree-diff-export-check.js.map

package/dist/scripts/git-worktree-manager-check.js

@@ -0,0 +1,37 @@
+#!/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, run } 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('worktree-manager');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-manager-'));
+delete process.env.SKS_ALLOW_IN_REPO_WORKTREES;
+const allocation = await managerMod.allocateWorkerWorktree({
+    repoRoot: repo,
+    missionId: 'M-manager',
+    workerId: 'worker-1',
+    slotId: 'slot-001',
+    generationIndex: 1
+});
+assertGate(allocation.ok === true, 'worker worktree allocation must pass', allocation);
+assertGate(fs.existsSync(allocation.worktree_path), 'allocated worktree path must exist', allocation);
+assertGate(!path.resolve(allocation.worktree_path).startsWith(path.resolve(repo) + path.sep), 'worktree must be outside main repo by default', allocation);
+assertGate(fs.existsSync(allocation.manifest_path), 'worktree manifest must be written', allocation);
+assertGate(run('git', ['status', '--porcelain=v1'], repo).trim() === '', 'main repo must stay clean after allocation');
+const cleanup = await cleanupMod.cleanupGitWorktree({
+    repoRoot: repo,
+    worktreePath: allocation.worktree_path,
+    branch: allocation.branch,
+    deleteBranch: true
+});
+assertGate(cleanup.ok === true && cleanup.action === 'removed', 'clean worktree cleanup must remove allocation', cleanup);
+emitGate('git:worktree-manager', {
+    worktree_outside_repo: true,
+    branch: allocation.branch,
+    cleanup: cleanup.action
+});
+//# sourceMappingURL=git-worktree-manager-check.js.map

package/dist/scripts/git-worktree-merge-queue-check.js

@@ -0,0 +1,30 @@
+#!/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 diffMod = await importDist('core/git/git-worktree-diff.js');
+const integrationMod = await importDist('core/git/git-integration-worktree.js');
+const queueMod = await importDist('core/git/git-worktree-merge-queue.js');
+const repo = makeGitFixture('worktree-merge');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-merge-'));
+const a = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-merge', workerId: 'a', slotId: 'slot-001' });
+const b = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-merge', workerId: 'b', slotId: 'slot-002' });
+fs.writeFileSync(path.join(a.worktree_path, 'a.txt'), 'alpha\nfrom-a\n');
+fs.writeFileSync(path.join(b.worktree_path, 'b.txt'), 'bravo\nfrom-b\n');
+const diffA = await diffMod.exportGitWorktreeDiff({ mainRepoRoot: repo, worktreePath: a.worktree_path, missionId: 'M-merge', workerId: 'a' });
+const diffB = await diffMod.exportGitWorktreeDiff({ mainRepoRoot: repo, worktreePath: b.worktree_path, missionId: 'M-merge', workerId: 'b' });
+const integration = await integrationMod.createGitIntegrationWorktree({ repoRoot: repo, missionId: 'M-merge' });
+const report = await queueMod.applyGitWorktreeMergeQueue({ integrationWorktreePath: integration.worktree_path, diffs: [diffA, diffB] });
+assertGate(report.ok === true && report.applied_count === 2, 'merge queue must apply non-conflicting worktree diffs', report);
+assertGate(fs.readFileSync(path.join(integration.worktree_path, 'a.txt'), 'utf8').includes('from-a'), 'integration worktree must include first diff');
+assertGate(fs.readFileSync(path.join(integration.worktree_path, 'b.txt'), 'utf8').includes('from-b'), 'integration worktree must include second diff');
+assertGate(fs.readFileSync(path.join(repo, 'a.txt'), 'utf8') === 'alpha\n', 'main worktree must remain unchanged before integration commit');
+emitGate('git:worktree-merge-queue', {
+    applied_count: report.applied_count,
+    changed_files: report.changed_files
+});
+//# sourceMappingURL=git-worktree-merge-queue-check.js.map

package/dist/scripts/git-worktree-pool-performance-check.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const poolMod = await importDist('core/git/git-worktree-pool.js');
+const workerIds = Array.from({ length: 100 }, (_, index) => `worker-${index + 1}`);
+const reusable = Array.from({ length: 32 }, (_, index) => `/tmp/reuse-${index + 1}`);
+const start = Date.now();
+const plan = poolMod.planGitWorktreePool({ workerIds, reusableWorktrees: reusable });
+const elapsed = Date.now() - start;
+assertGate(plan.ok === true, 'pool plan must pass', plan);
+assertGate(plan.assignments.length === 100, 'pool must assign every requested worker', plan);
+assertGate(plan.assignments.filter((row) => row.action === 'reuse').length === 32, 'pool must reuse available worktrees first', plan);
+assertGate(plan.allocate_count === 68, 'pool must allocate only the remaining workers', plan);
+assertGate(elapsed < 100, 'pool plan must stay fast for 100 workers', { elapsed });
+emitGate('git:worktree-pool-performance', {
+    elapsed_ms: elapsed,
+    reusable: 32,
+    allocate_count: plan.allocate_count
+});
+//# sourceMappingURL=git-worktree-pool-performance-check.js.map

package/dist/scripts/lib/git-worktree-fixture.js

@@ -0,0 +1,33 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+export function makeGitFixture(name) {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), `sks-${name}-`));
+    run('git', ['init'], root);
+    run('git', ['config', 'user.email', 'sks@example.invalid'], root);
+    run('git', ['config', 'user.name', 'SKS Test'], root);
+    fs.writeFileSync(path.join(root, 'a.txt'), 'alpha\n');
+    fs.writeFileSync(path.join(root, 'b.txt'), 'bravo\n');
+    run('git', ['add', 'a.txt', 'b.txt'], root);
+    run('git', ['commit', '-m', 'fixture'], root);
+    return root;
+}
+export function makeNonGitFixture(name) {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), `sks-${name}-`));
+    fs.writeFileSync(path.join(root, 'plain.txt'), 'not git\n');
+    return root;
+}
+export function run(command, args, cwd, input) {
+    const result = spawnSync(command, args, {
+        cwd,
+        input,
+        encoding: 'utf8',
+        stdio: input === undefined ? ['ignore', 'pipe', 'pipe'] : ['pipe', 'pipe', 'pipe']
+    });
+    if (result.status !== 0) {
+        throw new Error(`${command} ${args.join(' ')} failed in ${cwd}: ${result.stderr || result.stdout}`);
+    }
+    return result.stdout || '';
+}
+//# sourceMappingURL=git-worktree-fixture.js.map

package/dist/scripts/naruto-active-pool-check.js

@@ -15,13 +15,25 @@ const governor = governorMod.decideNarutoConcurrency({
 const report = activePool.simulateNarutoActivePool({ graph, governor: { ...governor, safe_active_workers: 5 } });
 assertGate(report.ok === true, 'active pool must drain cleanly', report);
 assertGate(report.max_observed_active_workers <= 5, 'active pool must never exceed safe cap', report);
+assertGate(report.max_observed_write_lease_conflicts === 0, 'active pool must never run overlapping write leases concurrently', report);
 assertGate(report.completed_count >= graph.total_work_items, 'active pool must complete all base work items', report);
 assertGate(report.refill_events >= 5, 'active pool must refill slots as work drains', report);
 assertGate(report.duplicate_execution_count === 0, 'active pool must not duplicate work without retry', report);
+const sameLeaseGraph = workGraph.buildNarutoWorkGraph({
+    requestedClones: 10,
+    totalWorkItems: 10,
+    writeCapable: true,
+    targetPaths: ['src/shared-fixture.ts'],
+    maxActiveWorkers: 5
+});
+const sameLeaseReport = activePool.simulateNarutoActivePool({ graph: sameLeaseGraph, governor: { ...governor, safe_active_workers: 5 } });
+assertGate(sameLeaseReport.ok === true, 'same-file work graph must drain without overlapping write leases', sameLeaseReport);
+assertGate(sameLeaseReport.max_observed_write_lease_conflicts === 0, 'same-file write items must be serialized or interleaved with read-only work only', sameLeaseReport);
 emitGate('naruto:active-pool', {
     safe_active_workers: report.safe_active_workers,
     completed_count: report.completed_count,
     refill_events: report.refill_events,
-    max_observed_active_workers: report.max_observed_active_workers
+    max_observed_active_workers: report.max_observed_active_workers,
+    same_lease_max_write_conflicts: sameLeaseReport.max_observed_write_lease_conflicts
 });
 //# sourceMappingURL=naruto-active-pool-check.js.map

package/dist/scripts/naruto-readonly-routing-check.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { assertGate, emitGate, exists, importDist, root } from './sks-1-18-gate-lib.js';
+const worker = await importDist('core/agents/agent-worker-pipeline.js');
+const cli = path.join(root, 'dist', 'bin', 'sks.js');
+assertGate(exists('dist/bin/sks.js'), 'dist/bin/sks.js missing (build first)');
+const readOnlyWorker = worker.validateAgentWorkerResult({
+    mission_id: 'M-readonly-routing',
+    agent_id: 'readonly-agent',
+    session_id: 'readonly-session',
+    persona_id: 'verifier',
+    task_slice_id: 'readonly-slice',
+    status: 'done',
+    backend: 'codex-sdk',
+    summary: 'Read-only worker inspected files without proposing a patch.',
+    findings: ['read-only inspection completed'],
+    proposed_changes: [],
+    changed_files: ['src/core/agents/agent-proof-evidence.ts'],
+    lease_compliance: { ok: true, violations: [] },
+    artifacts: [],
+    blockers: [],
+    confidence: 'fixture',
+    handoff_notes: '',
+    unverified: [],
+    writes: [],
+    no_patch_reason: {
+        ok: true,
+        reason: 'read_only_or_no_write_paths',
+        read_only_or_noop_evidence: true
+    },
+    verification: { status: 'passed', checks: ['readonly-no-patch-routing'] }
+});
+assertGate(readOnlyWorker.status === 'done' && !readOnlyWorker.blockers.includes('no_patch_generated'), 'read-only/no-write worker changed_files must not require patch envelopes', readOnlyWorker);
+const writeWorker = worker.validateAgentWorkerResult({
+    ...readOnlyWorker,
+    agent_id: 'write-agent',
+    session_id: 'write-session',
+    task_slice_id: 'write-slice',
+    changed_files: ['src/core/agents/agent-proof-evidence.ts'],
+    no_patch_reason: undefined
+});
+assertGate(writeWorker.status === 'blocked' && writeWorker.blockers.includes('no_patch_generated'), 'write-capable changed_files without patch envelope must still block', writeWorker);
+const readonlyRun = spawnSync(process.execPath, [
+    cli,
+    'naruto',
+    'run',
+    'readonly routing must inspect `src/core/agents/agent-proof-evidence.ts` and `package.json` without writes',
+    '--clones',
+    '4',
+    '--work-items',
+    '4',
+    '--backend',
+    'fake',
+    '--readonly',
+    '--json'
+], { cwd: root, encoding: 'utf8', timeout: 120000, maxBuffer: 6 * 1024 * 1024 });
+const readonlyJson = parseJson(readonlyRun.stdout);
+assertGate(readonlyRun.status === 0 && readonlyJson?.ok === true, 'readonly Naruto fake blackbox must exit ok', { status: readonlyRun.status, stdout: tail(readonlyRun.stdout), stderr: tail(readonlyRun.stderr) });
+assertGate(readonlyJson.proof === 'passed', 'readonly Naruto proof must pass', { proof: readonlyJson.proof, blockers: readonlyJson.run?.proof?.blockers });
+assertGate(readonlyJson.work_graph?.write_allowed_count === 0, 'readonly Naruto work graph must have zero write-allowed items', readonlyJson.work_graph);
+assertGate(Number(readonlyJson.role_distribution?.implementation_like_workers || 0) === 0, 'readonly Naruto role distribution must have zero implementation-like workers', readonlyJson.role_distribution);
+assertGate((readonlyJson.role_distribution?.entries || []).every((entry) => entry.write_allowed === false), 'readonly Naruto role distribution must deny writes for every role', readonlyJson.role_distribution);
+const readonlyRoot = path.join(root, '.sneakoscope', 'missions', readonlyJson.mission_id, 'agents');
+const readonlyProof = readJson(path.join(readonlyRoot, 'agent-proof-evidence.json'));
+const readonlyStrategy = readJson(path.join(readonlyRoot, 'user-request-strategy.json'));
+const readonlyPolicy = readJson(path.join(readonlyRoot, 'agent-parallel-write-policy.json'));
+assertGate(readonlyPolicy.write_mode === 'off' && readonlyPolicy.readonly === true, 'readonly run must force native write policy off', readonlyPolicy);
+assertGate(readonlyStrategy.gate?.write_task_count === 0, 'readonly strategy must not infer write targets from file mentions', readonlyStrategy.gate);
+assertGate(readonlyProof.changed_files_lease_checked === false, 'readonly no-write proof must skip changed_files write-lease checks', readonlyProof);
+assertGate(!(readonlyProof.blockers || []).some((blocker) => /no_patch_generated|lease_changed_file_violation/.test(String(blocker))), 'readonly proof must not contain patch/lease write blockers', readonlyProof.blockers || []);
+const writeRun = spawnSync(process.execPath, [
+    cli,
+    'naruto',
+    'run',
+    'write-capable routing must patch `README.md` through leased envelopes',
+    '--clones',
+    '3',
+    '--work-items',
+    '3',
+    '--backend',
+    'fake',
+    '--parallel-write',
+    '--json'
+], { cwd: root, encoding: 'utf8', timeout: 120000, maxBuffer: 6 * 1024 * 1024 });
+const writeJson = parseJson(writeRun.stdout);
+assertGate(writeRun.status === 0 && writeJson?.ok === true, 'write-capable Naruto fake blackbox must exit ok', { status: writeRun.status, stdout: tail(writeRun.stdout), stderr: tail(writeRun.stderr) });
+const writeRoot = path.join(root, '.sneakoscope', 'missions', writeJson.mission_id, 'agents');
+const writeStrategy = readJson(path.join(writeRoot, 'user-request-strategy.json'));
+const writePolicy = readJson(path.join(writeRoot, 'agent-parallel-write-policy.json'));
+assertGate(writePolicy.write_mode === 'parallel' && writePolicy.readonly === false, 'write-capable Naruto run must carry parallel write policy', writePolicy);
+assertGate(writeStrategy.gate?.write_task_count >= 1, 'write-capable strategy must retain explicit write target inference', writeStrategy.gate);
+emitGate('naruto:readonly-routing', {
+    readonly_mission_id: readonlyJson.mission_id,
+    write_mission_id: writeJson.mission_id,
+    readonly_write_tasks: readonlyStrategy.gate?.write_task_count,
+    write_write_tasks: writeStrategy.gate?.write_task_count
+});
+function readJson(file) {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+function tail(value, limit = 2000) {
+    const text = String(value || '');
+    return text.length <= limit ? text : text.slice(-limit);
+}
+//# sourceMappingURL=naruto-readonly-routing-check.js.map

package/dist/scripts/naruto-shadow-clone-swarm-check.js

@@ -5,6 +5,8 @@
 // changing it for any other route, and that an end-to-end `sks naruto run` actually
 // schedules >20 concurrent clone sessions to completion with proof.
 import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { assertGate, emitGate, importDist, root, exists } from './sks-1-18-gate-lib.js';
 const schema = await importDist('core/agents/agent-schema.js');
@@ -70,8 +72,10 @@ assertGate(bigMemoryHost.cap >= 64, 'a 64 GB host must allow >= 64 parallel code
 //    concurrency is throttled to the host-safe cap (never the full 24 unless the host allows).
 const proofClones = 24;
 const cli = path.join(root, 'dist', 'bin', 'sks.js');
+const isolatedWorktreeRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-naruto-shadow-wt-'));
+const childEnv = { ...process.env, SKS_WORKTREE_ROOT: isolatedWorktreeRoot };
 assertGate(exists('dist/bin/sks.js'), 'dist/bin/sks.js missing (build first)');
-const helpRun = spawnSync(process.execPath, [cli, 'naruto', '--help', '--json'], { cwd: root, encoding: 'utf8', timeout: 30000, maxBuffer: 1024 * 1024 });
+const helpRun = spawnSync(process.execPath, [cli, 'naruto', '--help', '--json'], { cwd: root, env: childEnv, encoding: 'utf8', timeout: 30000, maxBuffer: 1024 * 1024 });
 const helpParsed = parseJson(helpRun.stdout);
 assertGate(helpRun.status === 0 && helpParsed?.action === 'help', 'sks naruto --help must emit help instead of launching a run', { status: helpRun.status, stdout: tail(helpRun.stdout), stderr: tail(helpRun.stderr) });
 const run = spawnSync(process.execPath, [
@@ -80,7 +84,7 @@ const run = spawnSync(process.execPath, [
     '--backend', 'fake',
     '--work-items', String(proofClones),
     '--json'
-], { cwd: root, encoding: 'utf8', timeout: 240000, maxBuffer: 8 * 1024 * 1024 });
+], { cwd: root, env: childEnv, encoding: 'utf8', timeout: 240000, maxBuffer: 8 * 1024 * 1024 });
 assertGate(run.status === 0, 'sks naruto run must exit 0', { status: run.status, stderr: tail(run.stderr) });
 const parsed = parseJson(run.stdout);
 assertGate(parsed !== null, 'sks naruto run must emit JSON', { stdout: tail(run.stdout) });
@@ -98,15 +102,21 @@ assertGate(typeof parsed.concurrency_capped === 'boolean', 'naruto run must repo
 assertGate(parsed.concurrency_capped === (parsed.clones > parsed.target_active_slots), 'concurrency_capped must reflect clones > live slots', { clones: parsed.clones, target_active_slots: parsed.target_active_slots, concurrency_capped: parsed.concurrency_capped });
 assertGate(parsed.system && Number(parsed.system.safe_concurrency) >= 1, 'naruto run must report system safe_concurrency (host-derived cap)', { system: parsed.system });
 assertGate(parsed.work_graph?.write_allowed_count > 0 && parsed.work_graph?.mixed_work_kinds?.length > 1, 'naruto run must report a mixed work graph with write-capable items', { work_graph: parsed.work_graph });
+assertGate(Number(parsed.work_graph?.parallel_write_wave_count || 0) > 0, 'naruto run must expose at least one parallel write-capable wave with non-overlapping leases', { work_graph: parsed.work_graph });
 assertGate(parsed.role_distribution?.verifier_only === false, 'naruto run proof/status must distinguish active worker roles beyond verifier-only', { role_distribution: parsed.role_distribution });
 assertGate(Number(parsed.role_distribution?.implementation_like_ratio || 0) >= 0.4, 'naruto run must include implementation-like role distribution', { role_distribution: parsed.role_distribution });
+const commandGraphPath = path.join(root, '.sneakoscope', 'missions', parsed.mission_id, 'agents', 'naruto-work-graph.json');
+const commandGraph = JSON.parse(fs.readFileSync(commandGraphPath, 'utf8'));
+const writePaths = commandGraph.work_items.filter((row) => row.write_allowed).flatMap((row) => row.write_paths);
+assertGate(new Set(writePaths).size > 1, 'naruto command default patch-envelope leases must be per work item, not one shared write path', { sample: writePaths.slice(0, 8), unique: new Set(writePaths).size });
+assertGate(commandGraph.active_waves.some((wave) => wave.write_paths.length > 1), 'naruto command graph must contain a parallel write wave when route-local patch envelopes do not overlap', { waves: commandGraph.active_waves.slice(0, 3) });
 const state = parsed.run?.scheduler?.state || parsed.run?.scheduler || {};
 assertGate(Number(state.completed_count) === proofClones, 'all clone work items must complete despite throttling', { completed_count: state.completed_count });
-const explicitConcurrency = spawnSync(process.execPath, [cli, 'naruto', 'run', 'explicit concurrency', '--clones', '6', '--backend', 'fake', '--work-items', '6', '--concurrency', '6', '--json'], { cwd: root, encoding: 'utf8', timeout: 120000, maxBuffer: 4 * 1024 * 1024 });
+const explicitConcurrency = spawnSync(process.execPath, [cli, 'naruto', 'run', 'explicit concurrency', '--clones', '6', '--backend', 'fake', '--work-items', '6', '--concurrency', '6', '--json'], { cwd: root, env: childEnv, encoding: 'utf8', timeout: 120000, maxBuffer: 4 * 1024 * 1024 });
 const explicitParsed = parseJson(explicitConcurrency.stdout);
 assertGate(explicitConcurrency.status === 0 && explicitParsed?.target_active_slots === 6, 'explicit --concurrency must let Naruto use the requested parallel slot count', { status: explicitConcurrency.status, target_active_slots: explicitParsed?.target_active_slots });
 // 7) A small request is NOT throttled below what was asked (cap only ever reduces, never inflates).
-const small = spawnSync(process.execPath, [cli, 'naruto', 'run', 'tiny', '--clones', '2', '--backend', 'fake', '--work-items', '2', '--json'], { cwd: root, encoding: 'utf8', timeout: 120000, maxBuffer: 4 * 1024 * 1024 });
+const small = spawnSync(process.execPath, [cli, 'naruto', 'run', 'tiny', '--clones', '2', '--backend', 'fake', '--work-items', '2', '--json'], { cwd: root, env: childEnv, encoding: 'utf8', timeout: 120000, maxBuffer: 4 * 1024 * 1024 });
 const smallParsed = parseJson(small.stdout);
 assertGate(small.status === 0 && smallParsed?.target_active_slots === 2, 'a 2-clone run must run 2 concurrently (no over-throttle)', { status: small.status, target_active_slots: smallParsed?.target_active_slots });
 emitGate('naruto:shadow-clone-swarm', {
@@ -121,7 +131,8 @@ emitGate('naruto:shadow-clone-swarm', {
     low_free_capable_cap: lowFreeButCapable.cap,
     cores: heavySafe.cores,
     completed_count: state.completed_count,
-    mission_id: parsed.mission_id
+    mission_id: parsed.mission_id,
+    isolated_worktree_root: isolatedWorktreeRoot
 });
 function parseJson(text) {
     try {

package/dist/scripts/naruto-worktree-coding-check.js

@@ -0,0 +1,44 @@
+#!/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, makeNonGitFixture } from './lib/git-worktree-fixture.js';
+const capabilityMod = await importDist('core/git/git-worktree-capability.js');
+const workGraphMod = await importDist('core/naruto/naruto-work-graph.js');
+const activePoolMod = await importDist('core/naruto/naruto-active-pool.js');
+const governorMod = await importDist('core/naruto/naruto-concurrency-governor.js');
+const repo = makeGitFixture('naruto-worktree-coding');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-naruto-wt-'));
+const capability = await capabilityMod.evaluateGitWorktreeCapability({ root: repo, missionId: 'M-naruto-wt', requireGitWorktree: process.argv.includes('--require-real') });
+const policy = {
+    mode: capability.mode,
+    required: capability.mode === 'git-worktree',
+    main_repo_root: capability.detection.root,
+    worktree_root: capability.root_resolution?.root || null,
+    fallback_reason: capability.mode === 'git-worktree' ? null : capability.blockers.join(';')
+};
+const graph = workGraphMod.buildNarutoWorkGraph({
+    requestedClones: 8,
+    totalWorkItems: 12,
+    writeCapable: true,
+    targetPaths: Array.from({ length: 12 }, (_, index) => `src/wt-${index}.ts`),
+    maxActiveWorkers: 4,
+    worktreePolicy: policy
+});
+const governor = governorMod.decideNarutoConcurrency({ requestedClones: 8, totalWorkItems: 12, pendingWorkQueueSize: 12, backend: 'fake' });
+const pool = await activePoolMod.runNarutoActivePool({ graph, governor: { ...governor, safe_active_workers: 4 } });
+assertGate(capability.ok === true && capability.mode === 'git-worktree', 'Git Naruto coding fixture must use git-worktree mode', capability);
+assertGate(graph.worktree_policy.mode === 'git-worktree', 'Naruto work graph must carry git-worktree policy', graph.worktree_policy);
+assertGate(graph.work_items.filter((item) => item.write_allowed).every((item) => item.worktree?.allocation_required === true), 'write-capable work items must require worktree allocation', graph.work_items);
+assertGate(pool.worktree_allocation_required_count > 0, 'active pool must plan worktree allocations for write work', pool);
+const nonGit = makeNonGitFixture('naruto-worktree-non-git');
+const nonGitCapability = await capabilityMod.evaluateGitWorktreeCapability({ root: nonGit, missionId: 'M-naruto-non-git' });
+assertGate(nonGitCapability.mode === 'patch-envelope-only' && nonGitCapability.worktree_probe_attempted === false, 'non-Git Naruto must degrade without worktree probe', nonGitCapability);
+emitGate('naruto:worktree-coding', {
+    worktree_mode: graph.worktree_policy.mode,
+    allocation_required_count: pool.worktree_allocation_required_count,
+    non_git_mode: nonGitCapability.mode
+});
+//# sourceMappingURL=naruto-worktree-coding-check.js.map

package/dist/scripts/naruto-worktree-gpt-final-check.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const workGraphMod = await importDist('core/naruto/naruto-work-graph.js');
+const rolesMod = await importDist('core/naruto/naruto-role-policy.js');
+const packMod = await importDist('core/naruto/naruto-gpt-final-pack.js');
+const policy = {
+    mode: 'git-worktree',
+    required: true,
+    main_repo_root: '/repo',
+    worktree_root: '/cache/sks/worktrees/repo/M-final',
+    fallback_reason: null
+};
+const graph = workGraphMod.buildNarutoWorkGraph({ requestedClones: 6, totalWorkItems: 8, writeCapable: true, worktreePolicy: policy });
+const roleDistribution = rolesMod.buildNarutoRoleDistribution(graph.work_items);
+const worktreeDiff = {
+    schema: 'sks.git-worktree-diff.v1',
+    ok: true,
+    mission_id: 'M-final',
+    worker_id: 'worker-1',
+    main_repo_root: '/repo',
+    worktree_path: '/cache/wt/worker-1',
+    branch: 'sks/M/worker-1',
+    changed_files: ['src/a.ts'],
+    diff: 'diff --git a/src/a.ts b/src/a.ts\n',
+    diff_bytes: 37
+};
+const pack = packMod.buildNarutoGptFinalPack({
+    missionId: 'M-final',
+    graph,
+    roleDistribution,
+    changedFiles: ['src/a.ts'],
+    worktreePolicy: policy,
+    worktreeDiffs: [worktreeDiff],
+    localLlmMetrics: { participated: true, final_status: 'draft_until_gpt_final' }
+});
+assertGate(pack.worktree_policy.mode === 'git-worktree', 'GPT final pack must include worktree policy', pack.worktree_policy);
+assertGate(pack.worktree_diffs.length === 1, 'GPT final pack must include bounded worktree diffs', pack);
+assertGate(pack.local_llm_metrics.final_status === 'draft_until_gpt_final', 'local LLM output must remain draft until GPT final', pack.local_llm_metrics);
+assertGate(pack.bounded === true && pack.secrets_redacted === true, 'GPT final pack must stay bounded/redacted', pack);
+emitGate('naruto:worktree-gpt-final', {
+    worktree_mode: pack.worktree_policy.mode,
+    worktree_diffs: pack.worktree_diffs.length
+});
+//# sourceMappingURL=naruto-worktree-gpt-final-check.js.map

package/dist/scripts/naruto-worktree-zellij-ui-check.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const dashboardMod = await importDist('core/zellij/zellij-naruto-dashboard.js');
+const plan = dashboardMod.planNarutoZellijDashboard({
+    targetActiveWorkers: 10,
+    visiblePaneCap: 6,
+    roles: ['implementer', 'verifier'],
+    backend: 'codex-sdk',
+    worktreePolicy: {
+        mode: 'git-worktree',
+        required: true,
+        main_repo_root: '/repo',
+        worktree_root: '/cache/sks/worktrees/repo/M',
+        fallback_reason: null
+    }
+});
+assertGate(plan.ok === true, 'Naruto worktree Zellij dashboard must pass', plan);
+assertGate(plan.worktree_mode === 'git-worktree', 'dashboard must carry worktree mode', plan);
+assertGate(plan.worktree_labels.length === plan.visible_worker_panes, 'visible panes must have worktree labels', plan);
+assertGate(plan.pane_titles.every((title) => title.includes('WT:') && title.includes('branch:')), 'pane titles must include worktree id and branch', plan.pane_titles);
+assertGate(plan.headless_workers === 4, 'dashboard must still expose headless worker count', plan);
+emitGate('naruto:worktree-zellij-ui', {
+    visible_worker_panes: plan.visible_worker_panes,
+    headless_workers: plan.headless_workers,
+    sample_title: plan.pane_titles[0]
+});
+//# sourceMappingURL=naruto-worktree-zellij-ui-check.js.map