sneakoscope 3.1.0 → 3.1.2

package/dist/core/zellij/zellij-slot-telemetry.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import fsp from 'node:fs/promises';
-import { appendJsonlBounded, ensureDir, nowIso, readJson, readText } from '../fsx.js';
+import { appendJsonlBounded, ensureDir, nowIso, readJson, readText, writeTextAtomic } from '../fsx.js';
+import { withFileLock } from '../locks/file-lock.js';
 export const ZELLIJ_SLOT_TELEMETRY_EVENT_SCHEMA = 'sks.zellij-slot-telemetry-event.v1';
 export const ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA = 'sks.zellij-slot-telemetry-snapshot.v1';
 const telemetrySnapshotCache = new Map();
@@ -71,7 +72,7 @@ export function mergeTelemetrySnapshots(base, overlay, opts = {}) {
     const slots = { ...(base.slots || {}) };
     for (const [key, row] of Object.entries(overlay.slots || {})) {
         const existing = slots[key];
-        slots[key] = !existing || telemetryTsMs(row.latest_ts) >= telemetryTsMs(existing.latest_ts) ? row : existing;
+        slots[key] = !existing ? row : newerSlotTelemetry(existing, row);
     }
     const baseTs = Date.parse(String(base.updated_at || '')) || 0;
     const overlayTs = Date.parse(String(overlay.updated_at || '')) || 0;
@@ -88,6 +89,21 @@ function telemetryTsMs(value) {
     const parsed = Date.parse(String(value || ''));
     return Number.isFinite(parsed) ? parsed : 0;
 }
+function newerSlotTelemetry(current, incoming) {
+    const currentTs = telemetryTsMs(current.latest_ts);
+    const incomingTs = telemetryTsMs(incoming.latest_ts);
+    const currentTerminal = isTelemetryTerminalStatus(current.status);
+    const incomingTerminal = isTelemetryTerminalStatus(incoming.status);
+    if (currentTerminal && !incomingTerminal)
+        return current;
+    if (!currentTerminal && incomingTerminal)
+        return incoming;
+    if (incomingTs > currentTs)
+        return incoming;
+    if (incomingTs < currentTs)
+        return current;
+    return incoming;
+}
 async function statTelemetryFile(file) {
     try {
         const st = await fsp.stat(file);
@@ -99,17 +115,17 @@ async function statTelemetryFile(file) {
 }
 export function applyTelemetryEventToSnapshot(snapshot, event) {
     const key = slotTelemetryKey(event.slot_id || event.worker_id, event.generation_index);
-    const slots = {
-        ...(snapshot.slots || {}),
-        [key]: mergeSlotTelemetry(snapshot.slots?.[key], event)
-    };
+    const previous = snapshot.slots?.[key];
+    const nextSlot = mergeSlotTelemetry(previous, event);
+    const slots = snapshot.slots || {};
+    slots[key] = nextSlot;
     return {
         schema: ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA,
         mission_id: event.mission_id || snapshot.mission_id,
         updated_at: nowIso(),
         flush_count: snapshot.flush_count || 0,
         slots,
-        counts: countSlotTelemetry(slots)
+        counts: adjustSlotTelemetryCounts(snapshot.counts || countSlotTelemetry(snapshot.slots || {}), previous, nextSlot)
     };
 }
 export async function rebuildZellijSlotTelemetrySnapshot(root, missionId) {
@@ -176,11 +192,19 @@ function normalizeTelemetryEvent(event) {
     };
 }
 function mergeSlotTelemetry(previous, event) {
+    const previousTs = telemetryTsMs(previous?.latest_ts);
+    const eventTs = telemetryTsMs(event.ts);
+    const previousTerminal = isTelemetryTerminalStatus(previous?.status);
+    const eventTerminal = isTelemetryTerminalStatus(event.status);
+    const terminalRegression = Boolean(previous && previousTerminal && !eventTerminal);
+    const stale = Boolean(previous && (terminalRegression
+        || (!eventTerminal && eventTs < previousTs)
+        || (previousTerminal && eventTerminal && eventTs < previousTs)));
     return {
-        slot_id: event.slot_id,
-        generation_index: event.generation_index,
-        worker_id: event.worker_id,
-        status: event.status,
+        slot_id: stale ? previous.slot_id : event.slot_id,
+        generation_index: stale ? previous.generation_index : event.generation_index,
+        worker_id: stale ? previous.worker_id : event.worker_id,
+        status: stale ? previous.status : event.status,
         role: event.role || previous?.role || 'worker',
         backend: event.backend || previous?.backend || 'unknown',
         provider: event.provider || previous?.provider || 'unknown',
@@ -188,34 +212,55 @@ function mergeSlotTelemetry(previous, event) {
         worktree_id: event.worktree_id ?? previous?.worktree_id ?? null,
         worktree_path: event.worktree_path ?? previous?.worktree_path ?? null,
         task_title: event.task_title || previous?.task_title || 'waiting for task',
-        current_file: event.current_file ?? previous?.current_file ?? null,
-        latest_event_type: event.event_type,
-        latest_ts: event.ts,
-        progress: event.progress || previous?.progress || null,
+        current_file: stale ? previous.current_file ?? (terminalRegression ? null : event.current_file ?? null) : event.current_file ?? previous?.current_file ?? null,
+        latest_event_type: stale ? previous.latest_event_type : event.event_type,
+        latest_ts: stale ? previous.latest_ts : event.ts,
+        progress: stale ? previous.progress || (terminalRegression ? null : event.progress || null) : event.progress || previous?.progress || null,
         artifact_paths: unique([...(previous?.artifact_paths || []), ...(event.artifact_paths || [])]),
         blockers: unique([...(previous?.blockers || []), ...(event.blockers || [])]),
-        log_tail: event.log_tail || previous?.log_tail || ''
+        log_tail: stale ? previous.log_tail || (terminalRegression ? '' : event.log_tail || '') : event.log_tail || previous?.log_tail || ''
     };
 }
 function countSlotTelemetry(slots) {
     const counts = { queued: 0, running: 0, verifying: 0, completed: 0, failed: 0, headless: 0 };
     for (const row of Object.values(slots)) {
-        const status = normalizeStatus(row.status);
-        if (status === 'queued' || status === 'launching')
-            counts.queued += 1;
-        else if (status === 'running')
-            counts.running += 1;
-        else if (status === 'verifying')
-            counts.verifying += 1;
-        else if (status === 'completed' || status === 'drained')
-            counts.completed += 1;
-        else if (status === 'failed')
-            counts.failed += 1;
-        else if (status === 'headless')
-            counts.headless += 1;
+        const bucket = slotTelemetryCountBucket(row.status);
+        counts[bucket] += 1;
+    }
+    return counts;
+}
+function adjustSlotTelemetryCounts(current, previous, next) {
+    const counts = { ...current };
+    const nextBucket = slotTelemetryCountBucket(next.status);
+    if (previous) {
+        const previousBucket = slotTelemetryCountBucket(previous.status);
+        if (previousBucket !== nextBucket) {
+            counts[previousBucket] = Math.max(0, Number(counts[previousBucket] || 0) - 1);
+            counts[nextBucket] = Number(counts[nextBucket] || 0) + 1;
+        }
+        return counts;
     }
+    counts[nextBucket] = Number(counts[nextBucket] || 0) + 1;
     return counts;
 }
+function slotTelemetryCountBucket(status) {
+    const normalized = normalizeStatus(status);
+    if (normalized === 'queued' || normalized === 'launching')
+        return 'queued';
+    if (normalized === 'verifying')
+        return 'verifying';
+    if (normalized === 'completed' || normalized === 'drained')
+        return 'completed';
+    if (normalized === 'failed')
+        return 'failed';
+    if (normalized === 'headless')
+        return 'headless';
+    return 'running';
+}
+function isTelemetryTerminalStatus(status) {
+    const normalized = normalizeStatus(status);
+    return normalized === 'completed' || normalized === 'failed' || normalized === 'drained';
+}
 function normalizeStatus(value) {
     const text = String(value || '').toLowerCase();
     if (text === 'closed' || text === 'done' || text === 'passed')
@@ -258,20 +303,26 @@ function tail(value, max) {
 }
 async function writeTelemetrySnapshotFast(file, snapshot) {
     await ensureDir(path.dirname(file));
-    const flushCount = Number(telemetrySnapshotFlushCounts.get(file) || 0) + 1;
-    telemetrySnapshotFlushCounts.set(file, flushCount);
-    telemetrySnapshotLastFlushMs.set(file, Date.now());
-    // Merge with the on-disk snapshot before overwriting: multiple processes
-    // (orchestrator + worker children) flush this file concurrently and a plain
-    // overwrite would drop slots that only the other process has observed.
-    const disk = await readJson(file, null);
-    const merged = disk?.schema === ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA ? mergeTelemetrySnapshots(disk, snapshot) : snapshot;
-    const next = { ...merged, flush_count: Math.max(flushCount, Number(merged.flush_count || 0)) };
-    telemetrySnapshotCache.set(file, next);
-    await fsp.writeFile(file, `${JSON.stringify(next)}\n`, 'utf8');
-    const stat = await statTelemetryFile(file);
-    if (stat)
-        telemetrySnapshotDiskStat.set(file, stat);
+    await withFileLock({
+        lockPath: `${file}.lock`,
+        timeoutMs: 30000,
+        staleMs: 2 * 60 * 1000
+    }, async () => {
+        const flushCount = Number(telemetrySnapshotFlushCounts.get(file) || 0) + 1;
+        telemetrySnapshotFlushCounts.set(file, flushCount);
+        telemetrySnapshotLastFlushMs.set(file, Date.now());
+        // Multiple processes (orchestrator + worker children) flush this file.
+        // Serialize the read/merge/write critical section so a slower writer
+        // cannot overwrite a newer slot observed by a different process.
+        const disk = await readJson(file, null);
+        const merged = disk?.schema === ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA ? mergeTelemetrySnapshots(disk, snapshot) : snapshot;
+        const next = { ...merged, flush_count: Math.max(flushCount, Number(merged.flush_count || 0)) };
+        telemetrySnapshotCache.set(file, next);
+        await writeTextAtomic(file, `${JSON.stringify(next)}\n`);
+        const stat = await statTelemetryFile(file);
+        if (stat)
+            telemetrySnapshotDiskStat.set(file, stat);
+    });
 }
 function shouldFlushTelemetrySnapshot(file, event) {
     const next = (telemetrySnapshotWriteCounts.get(file) || 0) + 1;
@@ -289,7 +340,8 @@ function shouldFlushTelemetrySnapshot(file, event) {
         || event.event_type === 'worker_completed'
         || event.event_type === 'worker_failed'
         || event.status === 'completed'
-        || event.status === 'failed';
+        || event.status === 'failed'
+        || event.status === 'drained';
     const should = next === 1
         || important
         || now - last >= flushMs

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

@@ -14,12 +14,49 @@ export const ZELLIJ_PANE_CREATION_LOCK_METRICS_SCHEMA = 'sks.zellij-pane-creatio
 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, worktree) {
+export function buildWorkerPaneTitle(slotId, generationIndex, context, serviceTier, backend, status, worktree, taskTitle) {
+    // When a task label is available, the pane title is JUST the label + status:
+    // users identify panes by what they are doing, not by slot ids. Slot/gen,
+    // backend, provider, and worktree details stay inside the pane body and the
+    // SLOTS anchor rows. The verbose format remains the fallback for callers
+    // that have no task context.
+    const task = shortWorkerTaskLabel(taskTitle);
+    if (task)
+        return `${task} · ${workerBackendTag(backend, context?.provider)} · ${status || 'launching'}`;
     const base = buildWorkerPaneName(slotId, generationIndex);
     const normalized = normalizePaneProviderContext(context, serviceTier);
     const wt = worktree ? ` · WT:${worktree.id} · branch:${worktree.branch}` : '';
     return `${base}${wt} · ${backend || 'codex-sdk'} · ${providerPaneLabel(normalized)} · ${status || 'launching'}`;
 }
+// Local-LLM workers must be visually distinguishable from GPT/codex workers:
+// only trivial long-running edits belong on local models, while web research
+// and code review must run on GPT. The tag makes a misrouted task obvious.
+export function workerBackendTag(backend, provider) {
+    const text = `${String(backend || '')} ${String(provider || '')}`.toLowerCase();
+    if (/ollama|local/.test(text))
+        return 'LOCAL';
+    if (/fake|fixture/.test(text))
+        return 'fixture';
+    return 'GPT';
+}
+// Lead the pane title with a 1-3 word task label so users can tell WHAT each
+// slot is doing at a glance instead of an anonymous "slot-002/gen-1".
+export function shortWorkerTaskLabel(value, maxChars = 24) {
+    const text = String(value || '').replace(/\s+/g, ' ').trim();
+    if (!text)
+        return '';
+    const words = text.split(' ');
+    let label = '';
+    for (const word of words.slice(0, 3)) {
+        const next = label ? `${label} ${word}` : word;
+        if (next.length > maxChars)
+            break;
+        label = next;
+    }
+    if (!label)
+        label = text.slice(0, maxChars);
+    return label;
+}
 export function isRealZellijWorkerPaneIdSource(value) {
     return value === 'zellij_worker_new_pane_stdout' || value === 'zellij_worker_list_panes';
 }
@@ -162,7 +199,7 @@ export async function openWorkerPane(input) {
         });
         return record;
     }
-    const paneName = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier, input.backend, input.statusLabel || 'running', input.worktree || null);
+    const paneName = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier, input.backend, input.statusLabel || 'running', input.worktree || null, input.taskTitle || null);
     // CRITICAL: serialize anchor + worker pane creation per session. Workers
     // launch concurrently, and without this lock every worker raced past the
     // "does the SLOTS anchor exist yet?" check and created its OWN anchor with
@@ -695,7 +732,8 @@ async function withZellijPaneCreationLock(input, fn) {
     const current = new Promise((resolve) => {
         release = resolve;
     });
-    zellijPaneCreationLocks.set(key, previous.then(() => current, () => current));
+    const chained = previous.then(() => current, () => current);
+    zellijPaneCreationLocks.set(key, chained);
     await previous.catch(() => undefined);
     const acquiredAt = nowIso();
     const acquiredMs = Date.now();
@@ -741,7 +779,7 @@ async function withZellijPaneCreationLock(input, fn) {
             meta: { wait_ms: metrics.wait_ms, held_ms: metrics.held_ms }
         }).catch(() => undefined);
         release();
-        if (zellijPaneCreationLocks.get(key) === current)
+        if (zellijPaneCreationLocks.get(key) === chained)
             zellijPaneCreationLocks.delete(key);
     }
 }

package/dist/scripts/lib/native-cli-session-swarm-check-lib.js

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { assertGate, root } from '../sks-1-18-gate-lib.js';
-export function runNativeCliSwarmCheck({ agents, workItems = agents, reportName, backend = 'fake', extraArgs = [] }) {
+export function runNativeCliSwarmCheck({ agents, workItems = agents, reportName, backend = 'fake', extraArgs = [], expectedFastMode = null }) {
     const distCli = path.join(root, 'dist', 'bin', 'sks.js');
     assertGate(fs.existsSync(distCli), 'dist CLI missing for native CLI swarm check', { distCli });
     const args = [
@@ -37,7 +37,11 @@ export function runNativeCliSwarmCheck({ agents, workItems = agents, reportName,
     const result = JSON.parse(stdout);
     const proof = result.native_cli_session_proof || {};
     const noSubagent = result.no_subagent_scaling_policy || {};
+    const officialHelper = result.official_subagent_helper_policy || {};
     const fast = result.fast_mode_propagation || {};
+    const policy = fast.policy || result.fast_mode_policy || {};
+    const expectedFast = expectedFastMode === null || expectedFastMode === undefined ? Boolean(policy.fast_mode) : Boolean(expectedFastMode);
+    const expectedTier = expectedFast ? 'fast' : 'standard';
     const report = {
         schema: 'sks.native-cli-session-swarm-check.v1',
         ok: result.ok === true,
@@ -47,6 +51,7 @@ export function runNativeCliSwarmCheck({ agents, workItems = agents, reportName,
         backend: result.backend,
         native_cli_session_proof: proof,
         no_subagent_scaling_policy: noSubagent,
+        official_subagent_helper_policy: officialHelper,
         fast_mode_propagation: fast,
         proof_status: result.proof?.status || null
     };
@@ -60,7 +65,14 @@ export function runNativeCliSwarmCheck({ agents, workItems = agents, reportName,
     assertGate(Array.isArray(proof.process_ids) && proof.process_ids.length >= agents, 'process ids missing from native CLI proof', report);
     assertGate(proof.close_report_count >= agents, 'worker close report count below requested agents', report);
     assertGate(noSubagent.ok === true && noSubagent.subagent_events_counted_as_worker_sessions === false, 'no-subagent scaling policy must pass', report);
-    assertGate(fast.ok === true && fast.fast_mode === true && fast.service_tier === 'fast', 'fast mode must propagate by default', report);
+    assertGate(officialHelper.ok === true && officialHelper.official_codex_subagent_helper_lane_enabled === true, 'official subagent helper policy must pass', report);
+    assertGate(officialHelper.worker_capacity_credit === 0 && officialHelper.subagent_events_counted_as_worker_sessions === false, 'official helper lane must not count toward worker capacity', report);
+    assertGate(noSubagent.official_codex_subagent_helper_lane_allowed === true && noSubagent.official_helper_lane_worker_capacity_credit === 0, 'no-subagent policy must allow helper lane with zero capacity credit', report);
+    assertGate(fast.ok === true, 'fast mode propagation proof must pass', report);
+    assertGate(fast.fast_mode === expectedFast && fast.service_tier === expectedTier, 'worker service tier must match the selected fast-mode policy', { ...report, expected_fast_mode: expectedFast, expected_service_tier: expectedTier });
+    if (expectedFast) {
+        assertGate(policy.explicit_fast === true || policy.preference_mode === 'fast' || policy.explicit_service_tier === 'fast', 'fast-mode propagation gate must use explicit fast opt-in', report);
+    }
     assertGate((proof.worker_command_lines || []).every((line) => line.includes('--agent') && line.includes('worker')), 'worker command lines must use --agent worker', report);
     return report;
 }

package/dist/scripts/loop-directive-check-lib.js

@@ -4,6 +4,7 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { COMMANDS } from '../cli/command-registry.js';
+import { runProcess } from '../core/fsx.js';
 import { compileGoalToLoopPlan } from '../core/loops/goal-to-loop-compat.js';
 import { loopGraphProofPath, loopPlanPath, loopProofPath, loopRoot, loopStatePath } from '../core/loops/loop-artifacts.js';
 import { decomposeRequestIntoLoopDomains } from '../core/loops/loop-decomposer.js';
@@ -29,7 +30,18 @@ export async function runLoopDirectiveCheck(id) {
     const request = 'fix zellij telemetry, release cache, and codex probe docs';
     const plan = await planLoopsFromRequest({ root, missionId, request, sourceCommand: 'loop' });
     const byId = new Map(plan.graph.nodes.map((node) => [node.loop_id, node]));
-    const result = await runLoopPlan({ root, plan, parallelism: 'extreme', noMutation: id.includes('runtime') ? false : true });
+    const realRuntimeMode = process.env.SKS_LOOP_RUNTIME_REAL === '1'
+        || id === 'loop:runtime-real-workers'
+        || id === 'loop:maker-checker-real'
+        || id === 'loop:integration-finalizer-real'
+        || id === 'loop:real-maker-checker-blackbox'
+        || id === 'naruto:loop-mesh-real-blackbox'
+        || id === 'goal:loop-runtime-real-blackbox';
+    if (!realRuntimeMode && process.env.SKS_LOOP_RUNTIME_FIXTURE !== '1') {
+        process.env.SKS_LOOP_RUNTIME_FIXTURE = '1';
+    }
+    const fixtureMode = process.env.SKS_LOOP_RUNTIME_FIXTURE === '1' || process.env.SKS_LOOP_GATE_FIXTURE === '1';
+    const result = await runLoopPlan({ root, plan, parallelism: 'extreme', noMutation: fixtureMode ? true : !realRuntimeMode });
     const assertions = [];
     const assert = (condition, message) => assertions.push({ ok: Boolean(condition), message });
     assert(validateLoopPlan(plan).ok, 'loop plan validates');
@@ -40,6 +52,9 @@ export async function runLoopDirectiveCheck(id) {
     }
     else if (id === 'loop:artifact-paths') {
         assert(loopRoot(root, missionId).includes('.sneakoscope/missions'), 'artifact root layout matches directive');
+        assert(throws(() => loopRoot(root, '../../escape')), 'loop artifact root rejects mission traversal');
+        assert(throws(() => loopRoot(root, 'bad/mission')), 'loop artifact root rejects path separators in mission id');
+        assert(throws(() => loopStatePath(root, missionId, '../loop-escape')), 'loop node artifact path rejects loop traversal');
     }
     else if (id === 'loop:state') {
         assert(await exists(loopStatePath(root, missionId, 'loop-zellij')), 'loop state exists');
@@ -47,6 +62,8 @@ export async function runLoopDirectiveCheck(id) {
     else if (id === 'loop:planner') {
         assert(byId.has('loop-integration'), 'integration loop always created');
         assert(plan.graph.nodes.length >= 2, 'planner creates action plus integration loops');
+        assert(plan.graph.nodes.some((node) => node.route !== '$Integration' && node.maker.worker_count > 2), 'planner scales maker workers above the old hardcoded two');
+        assert(plan.graph.nodes.some((node) => node.route !== '$Integration' && node.checker.worker_count > 1), 'planner scales checker reviewers above the old hardcoded one');
     }
     else if (id === 'loop:decomposer') {
         const domains = decomposeRequestIntoLoopDomains(request);
@@ -68,6 +85,118 @@ export async function runLoopDirectiveCheck(id) {
         assert(result.ok, 'loop runtime produces ok graph result');
         assert(await exists(loopGraphProofPath(root, missionId)), 'graph proof exists');
     }
+    else if (id === 'loop:fixture-safety') {
+        const runtimeSource = await fs.readFile(path.join(process.cwd(), 'src/core/loops/loop-runtime.ts'), 'utf8');
+        const workerSource = await fs.readFile(path.join(process.cwd(), 'src/core/loops/loop-worker-runtime.ts'), 'utf8');
+        assert(!/noMutation\s*\?\s*\{\s*fixture:\s*true\s*\}/.test(runtimeSource), 'noMutation must not force fixture mode');
+        assert(workerSource.includes('decideLoopFixturePolicy'), 'fixture runtime has an explicit shared test-context policy guard');
+        assert(workerSource.includes('loop_fixture_runtime_forbidden'), 'fixture runtime fails closed outside test context');
+        assert(workerSource.includes("process.env.SKS_LOOP_RUNTIME_FIXTURE === '1'"), 'fixture runtime remains opt-in through SKS_LOOP_RUNTIME_FIXTURE');
+        assert(!workerSource.includes('visualLaneCount: Math.min(4'), 'zellij visual lane count must use the configurable pane cap');
+        const negative = await productionFixtureNegativeCheck();
+        assert(negative.code === 0 && negative.stdout.includes('loop_fixture_runtime_forbidden'), 'production fixture request is blocked at runtime');
+    }
+    else if (id === 'loop:worker-runtime') {
+        const proof = await readJson(loopProofPath(root, missionId, 'loop-zellij'));
+        assert(proof.maker_result.backend === 'deterministic-fixture' || proof.maker_result.backend === 'native-agent-orchestrator', 'maker backend recorded');
+        assert(proof.checker_result.backend === 'deterministic-fixture' || proof.checker_result.backend === 'native-agent-orchestrator', 'checker backend recorded');
+        assert(proof.maker_result.runtime_proof_path, 'maker runtime proof path recorded');
+        assert(proof.checker_result.runtime_proof_path, 'checker runtime proof path recorded');
+    }
+    else if (id === 'loop:worker-prompts') {
+        const prompts = await import('../core/loops/loop-worker-prompts.js');
+        const node = byId.get('loop-zellij');
+        assert(prompts.buildLoopMakerPrompt({ plan, node }).includes('Do not mutate outside the owner scope'), 'maker prompt constrains owner scope');
+        assert(prompts.buildLoopCheckerPrompt({ plan, node, makerArtifacts: ['maker.json'] }).includes('must not mutate source files'), 'checker prompt forbids mutation');
+        assert(prompts.buildLoopCheckerPrompt({ plan, node, makerArtifacts: ['maker.json'] }).includes('fresh session'), 'checker prompt requires fresh session');
+    }
+    else if (id === 'loop:runtime-real-workers' || id === 'loop:maker-checker-real') {
+        const proof = await readJson(loopProofPath(root, missionId, 'loop-zellij'));
+        assert(proof.maker_result.artifacts.length > 0, 'maker worker runtime artifacts exist');
+        assert(proof.checker_result.artifacts.length > 0, 'checker worker runtime artifacts exist');
+        assert(!proof.maker_result.artifacts.includes('fresh-checker-session'), 'placeholder checker string is not used');
+    }
+    else if (id === 'loop:checker-freshness') {
+        const proof = await readJson(loopProofPath(root, missionId, 'loop-zellij'));
+        const checker = await readJson(proof.checker_result.checker_findings[0]);
+        assert(checker.fresh_session === true, 'checker artifact proves fresh session');
+        assert(Array.isArray(checker.reviewed_maker_artifacts), 'checker reviewed maker artifacts');
+        assert(proof.checker_result.fresh_session === true, 'loop proof records checker freshness');
+    }
+    else if (id === 'loop:gate-registry') {
+        const registry = await import('../core/loops/loop-gate-registry.js');
+        const defs = await registry.listLoopGateDefinitions(process.cwd());
+        assert(defs.some((gate) => gate.id === 'gpt:final-arbiter' && gate.source === 'builtin-pseudo'), 'gpt final pseudo gate registered');
+        assert(await registry.resolveLoopGate(process.cwd(), 'definitely:unknown') === null, 'unknown gate does not resolve');
+    }
+    else if (id === 'loop:gate-runner-real' || id === 'loop:gate-artifacts') {
+        const proof = await readJson(loopProofPath(root, missionId, 'loop-zellij'));
+        assert(proof.gate_result.selected_gates.length > 0, 'gates selected');
+        assert(proof.gate_result.passed_gates.length > 0 || proof.gate_result.failed_gates.length > 0, 'gate outcomes recorded');
+        assert(await exists(path.join(loopRoot(root, missionId), 'loop-zellij', 'gates')), 'gate artifact directory exists');
+    }
+    else if (id === 'loop:worktree-runtime') {
+        assert(await exists(path.join(loopRoot(root, missionId), 'loop-zellij', 'worktree.json')), 'worktree record exists');
+    }
+    else if (id === 'loop:worktree-diff-scope') {
+        const mod = await import('../core/loops/loop-worktree-runtime.js');
+        assert(mod.enforceLoopOwnerScope(['src/core/zellij/zellij-slot-pane-renderer.ts'], byId.get('loop-zellij').owner_scope).length === 0, 'owner-scoped file passes');
+        assert(mod.enforceLoopOwnerScope(['README.md'], byId.get('loop-zellij').owner_scope).length > 0, 'outside owner scope blocks');
+    }
+    else if (id === 'loop:integration-merge') {
+        assert(await exists(path.join(loopRoot(root, missionId), 'integration-merge.json')), 'integration merge artifact exists');
+    }
+    else if (id === 'loop:integration-finalizer-real') {
+        const graph = await readJson(loopGraphProofPath(root, missionId));
+        assert(graph.integration_merge && typeof graph.integration_merge.ok === 'boolean', 'graph proof includes integration merge');
+    }
+    else if (id === 'file-lock:atomic') {
+        const lock = await import('../core/locks/file-lock.js');
+        let count = 0;
+        await lock.withFileLock({ lockPath: path.join(root, '.sneakoscope/locks/test.lock'), timeoutMs: 1000, staleMs: 10000 }, async () => { count += 1; });
+        assert(count === 1, 'file lock executes critical section');
+    }
+    else if (id === 'loop:lease-atomic') {
+        const node = byId.get('loop-zellij');
+        const lease = await acquireLoopLease(root, plan, node);
+        assert(lease.status === 'active' || lease.status === 'conflict', 'atomic lease returns status');
+    }
+    else if (id === 'loop:gpt-final-arbiter' || id === 'loop:integration-gpt-final') {
+        const mod = await import('../core/loops/loop-gpt-final-arbiter.js');
+        const arbiter = await mod.runLoopGptFinalArbiter({ root, plan, proofs: result.proofs, integrationMerge: { schema: 'sks.loop-integration-merge.v1', ok: true, applied_loops: [], conflict_loops: [], changed_files: ['src/core/loops/loop-runtime.ts'], blockers: [] }, forceVerdict: 'approve' });
+        assert(arbiter.ok && arbiter.verdict === 'approve', 'loop GPT final arbiter can approve');
+    }
+    else if (id === 'loop:checkpoint') {
+        assert(await exists(path.join(loopRoot(root, missionId), 'loop-zellij', 'checkpoint-latest.json')), 'latest checkpoint exists');
+    }
+    else if (id === 'loop:kill-resume' || id === 'loop:cli-kill-resume') {
+        const control = await import('../core/loops/loop-runtime-control.js');
+        await control.writeLoopKillRequest(root, missionId, 'loop-zellij');
+        assert(await control.shouldKillLoop(root, missionId, 'loop-zellij'), 'kill request targets loop');
+    }
+    else if (id === 'loop:real-maker-checker-blackbox') {
+        const proof = await readJson(loopProofPath(root, missionId, 'loop-zellij'));
+        assert(proof.maker_result.worker_count > 0 && proof.checker_result.worker_count > 0, 'maker/checker worker counts recorded');
+        assert(proof.checker_result.checker_findings.length > 0, 'checker findings artifact exists');
+    }
+    else if (id === 'naruto:loop-mesh-real-blackbox') {
+        assert(plan.graph.nodes.length >= 5, 'at least four domain loops plus integration are planned');
+        assert(result.proofs.every((proof) => proof.maker_result.artifacts.length && proof.checker_result.artifacts.length), 'worker runtime artifacts exist for every loop');
+        assert(result.graph_proof.integration_merge, 'integration finalizer ran');
+    }
+    else if (id === 'goal:loop-runtime-real-blackbox') {
+        const goalPlan = await compileGoalToLoopPlan({ root, missionId: `${missionId}-goal-real`, goalText: 'fix release cache', legacyGoalOptions: {} });
+        const goalResult = await runLoopPlan({ root, plan: goalPlan, parallelism: 'balanced', noMutation: true });
+        assert(await exists(path.join(root, '.sneakoscope', 'missions', `${missionId}-goal-real`, 'goal-compat.json')), 'goal compat artifact exists');
+        assert(goalResult.proofs.some((proof) => proof.maker_result.artifacts.length), 'goal loop worker runtime artifacts exist');
+        assert(await exists(loopGraphProofPath(root, `${missionId}-goal-real`)), 'goal graph proof exists');
+    }
+    else if (id === 'loop:status-ux') {
+        assert(await exists(loopGraphProofPath(root, missionId)), 'status has graph proof source');
+    }
+    else if (id === 'loop:zellij-real-runtime-ui') {
+        assert(renderZellijSlotPane({ slotId: 'slot-003', generationIndex: 1, loopId: 'loop-zellij', loopRole: 'maker', loopGate: 'loop:test', backend: 'fixture', patchStatus: 'fixture', verifyStatus: 'pass' }).includes('fixture loop proof'), 'zellij marks fixture proof');
+    }
     else if (id === 'loop:proof') {
         assert(await exists(loopProofPath(root, missionId, 'loop-zellij')), 'loop proof exists');
     }
@@ -85,6 +214,48 @@ export async function runLoopDirectiveCheck(id) {
         const node = byId.get('loop-zellij');
         const gates = await runLoopGates({ root, missionId, node, gates: node.gates });
         assert(gates.skipped_gates.includes('release:check') === false, 'gate runner avoids full release check inside loop');
+        const checkerDir = path.join(root, '.sneakoscope', 'missions', missionId, 'agents', 'sessions');
+        await fs.mkdir(checkerDir, { recursive: true });
+        await fs.writeFile(path.join(checkerDir, 'checker-findings.json'), JSON.stringify({ fresh_session: true, approved: true }));
+        const checkerGate = await runLoopGates({
+            root,
+            missionId,
+            node,
+            gates: { triage: [], local: [], checker: ['loop:checker-fresh-session'], integration: [], final: [] },
+            checkerArtifacts: ['sessions/checker-findings.json']
+        });
+        assert(checkerGate.ok, 'builtin checker gate resolves mission-ledger relative artifacts');
+        const foreignChecker = path.join(path.dirname(root), `${missionId}-foreign-checker-findings.json`);
+        await fs.writeFile(foreignChecker, JSON.stringify({ fresh_session: true, approved: true }));
+        const foreignRelative = path.relative(path.join(root, '.sneakoscope', 'missions', missionId, 'agents'), foreignChecker);
+        const unsafeCheckerGate = await runLoopGates({
+            root,
+            missionId,
+            node,
+            gates: { triage: [], local: [], checker: ['loop:checker-fresh-session'], integration: [], final: [] },
+            checkerArtifacts: [foreignRelative, foreignChecker]
+        });
+        assert(!unsafeCheckerGate.ok && unsafeCheckerGate.blockers.includes('loop_checker_fresh_session_missing'), 'builtin checker gate rejects foreign absolute and traversal artifacts');
+        const repoLocalChecker = path.join(root, 'repo-local-checker-findings.json');
+        await fs.writeFile(repoLocalChecker, JSON.stringify({ fresh_session: true, approved: true }));
+        const repoLocalCheckerGate = await runLoopGates({
+            root,
+            missionId,
+            node,
+            gates: { triage: [], local: [], checker: ['loop:checker-fresh-session'], integration: [], final: [] },
+            checkerArtifacts: ['repo-local-checker-findings.json', repoLocalChecker]
+        });
+        assert(!repoLocalCheckerGate.ok && repoLocalCheckerGate.blockers.includes('loop_checker_fresh_session_missing'), 'builtin checker gate rejects repo-local non-mission artifacts');
+        const symlinkChecker = path.join(checkerDir, 'checker-findings-symlink.json');
+        await fs.symlink(repoLocalChecker, symlinkChecker);
+        const symlinkCheckerGate = await runLoopGates({
+            root,
+            missionId,
+            node,
+            gates: { triage: [], local: [], checker: ['loop:checker-fresh-session'], integration: [], final: [] },
+            checkerArtifacts: ['sessions/checker-findings-symlink.json']
+        });
+        assert(!symlinkCheckerGate.ok && symlinkCheckerGate.blockers.includes('loop_checker_fresh_session_missing'), 'builtin checker gate rejects mission-local symlinks that escape the mission root');
     }
     else if (id === 'loop:gate-ladder') {
         const node = byId.get('loop-zellij');
@@ -108,7 +279,7 @@ export async function runLoopDirectiveCheck(id) {
         assert(docsA.status === 'active' && docsB.status === 'active', 'docs overlap is allowed when non-exclusive');
     }
     else if (id === 'naruto:loop-mesh' || id === 'naruto:loop-maker-checker') {
-        const mesh = await runNarutoLoopMesh({ root, plan, parallelism: 'balanced' });
+        const mesh = await runNarutoLoopMesh({ root, plan, parallelism: 'balanced', noMutation: fixtureMode ? true : !realRuntimeMode });
         assert(mesh.proofs.every((proof) => proof.maker_result.worker_count > 0 && proof.checker_result.worker_count > 0), 'maker/checker artifacts exist for each loop');
     }
     else if (id === 'naruto:loop-worker-router') {
@@ -159,7 +330,59 @@ async function exists(file) {
         return false;
     }
 }
+function throws(fn) {
+    try {
+        fn();
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
 async function readJson(file) {
     return JSON.parse(await fs.readFile(file, 'utf8'));
 }
+async function productionFixtureNegativeCheck() {
+    const code = `
+import { runLoopMakerWorkers } from './dist/core/loops/loop-worker-runtime.js';
+const node = {
+  mission_id: 'M-production-fixture-negative',
+  loop_id: 'loop-production-fixture-negative',
+  owner_scope: { files: ['README.md'], directories: [], package_scripts: [], release_gate_ids: [], exclusive: true, collision_policy: 'handoff' },
+  maker: { worker_count: 1 },
+  checker: { worker_count: 1 },
+  risk: { requires_gpt_final: false },
+  worktree: { required: false }
+};
+const plan = { mission_id: 'M-production-fixture-negative' };
+try {
+  await runLoopMakerWorkers({ root: process.cwd(), plan, node, fixture: true });
+  console.error('fixture unexpectedly allowed outside test context');
+  process.exit(1);
+} catch (err) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (!message.includes('loop_fixture_runtime_forbidden')) {
+    console.error(message);
+    process.exit(2);
+  }
+  console.log(message);
+}
+`;
+    return runProcess('/usr/bin/env', [
+        '-u', 'NODE_ENV',
+        '-u', 'SKS_TEST_RUNTIME_FIXTURE_ALLOWED',
+        '-u', 'VITEST_WORKER_ID',
+        '-u', 'JEST_WORKER_ID',
+        '-u', 'NODE_V8_COVERAGE',
+        'SKS_LOOP_RUNTIME_FIXTURE=1',
+        process.execPath,
+        '--input-type=module',
+        '-e',
+        code
+    ], {
+        cwd: process.cwd(),
+        timeoutMs: 30000,
+        maxOutputBytes: 8192
+    });
+}
 //# sourceMappingURL=loop-directive-check-lib.js.map