sneakoscope 3.1.1 → 3.1.2

package/dist/core/loops/loop-worker-runtime.js

@@ -1,9 +1,10 @@
 import path from 'node:path';
-import os from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { runNativeAgentOrchestrator } from '../agents/agent-orchestrator.js';
 import { ensureDir, nowIso, readJson, runProcess, writeJsonAtomic } from '../fsx.js';
 import { loopNodeRoot } from './loop-artifacts.js';
+import { computeLoopConcurrencyBudget, loopWorkerBudgetFor } from './loop-concurrency-budget.js';
+import { decideLoopFixturePolicy, writeLoopFixturePolicyDecision } from './loop-fixture-policy.js';
 import { buildLoopCheckerPrompt, buildLoopMakerPrompt } from './loop-worker-prompts.js';
 export async function runLoopMakerWorkers(input) {
     return runLoopWorkers({ ...input, phase: 'maker' });
@@ -24,9 +25,15 @@ function shouldUseFixture(input) {
     const requested = input.fixture === true || process.env.SKS_LOOP_RUNTIME_FIXTURE === '1';
     if (!requested)
         return false;
-    const allowed = loopFixtureAllowed(input);
-    if (!allowed.ok) {
-        throw new Error(`loop_fixture_runtime_forbidden:${allowed.reason}`);
+    const decision = decideLoopFixturePolicy({
+        root: input.root,
+        missionId: input.plan.mission_id,
+        mode: 'worker',
+        requested
+    });
+    void writeLoopFixturePolicyDecision(input.root, input.plan.mission_id, decision).catch(() => undefined);
+    if (!decision.allowed) {
+        throw new Error(`loop_fixture_runtime_forbidden:${decision.reason}:${decision.blockers.join(',')}`);
     }
     return true;
 }
@@ -34,7 +41,7 @@ async function runLoopWorkerNative(input) {
     const prompt = input.phase === 'maker'
         ? buildLoopMakerPrompt({ plan: input.plan, node: input.node, worktreePath: input.worktree?.path || null })
         : buildLoopCheckerPrompt({ plan: input.plan, node: input.node, makerArtifacts: input.makerArtifacts || [] });
-    const workerCount = input.phase === 'maker' ? input.node.maker.worker_count : input.node.checker.worker_count;
+    const workerCount = effectiveLoopWorkerCount(input);
     const workGraph = buildLoopNarutoWorkGraph(input, workerCount);
     // Root-cause-1 fix: keep the ORCHESTRATOR root on the MAIN repo (input.root), not the
     // loop worktree. All zellij/right-column/slot-telemetry state derives from the orchestrator
@@ -66,6 +73,12 @@ async function runLoopWorkerNative(input) {
         narutoMode: true,
         narutoWorkGraph: workGraph,
         ...zellijPlacementOpts,
+        env: {
+            SKS_LOOP_ID: input.node.loop_id,
+            SKS_LOOP_PHASE: input.phase,
+            SKS_LOOP_MAIN_ROOT: input.root,
+            SKS_LOOP_WORKER_BUDGET: String(workerCount)
+        },
         ...(input.worktree?.path ? {
             worktree: {
                 id: input.worktree.id || `loop-${input.node.loop_id}-${input.phase}`,
@@ -98,7 +111,7 @@ async function normalizeNativeResult(input, result) {
         mission_id: input.plan.mission_id,
         loop_id: input.node.loop_id,
         phase: input.phase,
-        worker_count: input.phase === 'maker' ? input.node.maker.worker_count : input.node.checker.worker_count,
+        worker_count: effectiveLoopWorkerCount(input),
         backend: 'native-agent-orchestrator',
         artifacts,
         patch_candidates: input.phase === 'maker' ? artifacts.filter((artifact) => artifact.includes('patch')) : [],
@@ -113,6 +126,12 @@ async function normalizeNativeResult(input, result) {
     return normalized;
 }
 async function runLoopWorkerFixture(input) {
+    const fixturePolicy = decideLoopFixturePolicy({
+        root: input.root,
+        missionId: input.plan.mission_id,
+        mode: 'worker',
+        requested: true
+    });
     const dir = path.join(loopNodeRoot(input.root, input.plan.mission_id, input.node.loop_id), input.phase);
     await ensureDir(dir);
     const resultPath = path.join(dir, 'worker-runtime-result.json');
@@ -150,7 +169,9 @@ async function runLoopWorkerFixture(input) {
             blockers: [`loop_worker_fixture_child_missing_result:${child.code}`],
             runtime_proof_path: resultPath,
             worker_ids: [],
-            session_ids: []
+            session_ids: [],
+            fixture_policy: fixturePolicy,
+            fixture_allowed_reason: fixturePolicy.allowed ? fixturePolicy.reason : null
         };
     }
     return {
@@ -159,7 +180,9 @@ async function runLoopWorkerFixture(input) {
         blockers: [
             ...result.blockers,
             ...(child.code === 0 ? [] : [`loop_worker_fixture_child_exit:${child.code}`])
-        ]
+        ],
+        fixture_policy: fixturePolicy,
+        fixture_allowed_reason: fixturePolicy.allowed ? fixturePolicy.reason : null
     };
 }
 function buildLoopNarutoWorkGraph(input, workerCount) {
@@ -250,26 +273,9 @@ function resolveLoopVisiblePaneCap(workerCount) {
 function fixtureChildEntrypoint() {
     return fileURLToPath(new URL('../../scripts/loop-worker-fixture-child.js', import.meta.url));
 }
-function loopFixtureAllowed(input) {
-    const argv = process.argv.join(' ');
-    const scriptIsCheck = /(?:^|\s)(?:.*[\/\\])?(?:dist|src)[\/\\]scripts[\/\\][^\s]*(?:check|blackbox)\.(?:js|ts)(?:\s|$)/.test(argv);
-    const explicitTestEnv = process.env.NODE_ENV === 'test'
-        || process.env.SKS_TEST_RUNTIME_FIXTURE_ALLOWED === '1'
-        || process.env.VITEST_WORKER_ID !== undefined
-        || process.env.JEST_WORKER_ID !== undefined
-        || process.env.NODE_V8_COVERAGE !== undefined;
-    const tempRoot = isUnderTempRoot(input.root) && /^M-check-/.test(input.plan.mission_id);
-    if (scriptIsCheck)
-        return { ok: true, reason: 'release_check_script' };
-    if (explicitTestEnv)
-        return { ok: true, reason: 'test_environment' };
-    if (tempRoot)
-        return { ok: true, reason: 'hermetic_temp_loop_check' };
-    return { ok: false, reason: 'fixture_requires_test_context' };
-}
-function isUnderTempRoot(root) {
-    const normalizedRoot = path.resolve(root);
-    const tempRoot = path.resolve(os.tmpdir());
-    return normalizedRoot === tempRoot || normalizedRoot.startsWith(`${tempRoot}${path.sep}`);
+function effectiveLoopWorkerCount(input) {
+    const requested = input.phase === 'maker' ? input.node.maker.worker_count : input.node.checker.worker_count;
+    const budget = computeLoopConcurrencyBudget({ plan: input.plan });
+    return loopWorkerBudgetFor(budget, input.node.loop_id, input.phase, requested);
 }
 //# sourceMappingURL=loop-worker-runtime.js.map

package/dist/core/naruto/naruto-loop-mesh.js

@@ -1,14 +1,17 @@
 import { writeJsonAtomic } from '../fsx.js';
+import { computeLoopConcurrencyBudget } from '../loops/loop-concurrency-budget.js';
 import { loopRoot } from '../loops/loop-artifacts.js';
 import { runLoopPlan } from '../loops/loop-runtime.js';
 import { routeNarutoLoopWorker } from './naruto-loop-worker-router.js';
 export async function runNarutoLoopMesh(input) {
     const routes = input.plan.graph.nodes.flatMap((node) => [routeNarutoLoopWorker(node, 'maker'), routeNarutoLoopWorker(node, 'checker')]);
     const activeWorkerBudget = splitActiveWorkerBudget(input.plan, input.parallelism);
+    const loopConcurrencyBudget = computeLoopConcurrencyBudget({ plan: input.plan, parallelism: input.parallelism });
     await writeJsonAtomic(`${loopRoot(input.root, input.plan.mission_id)}/naruto-loop-worker-routes.json`, {
         schema: 'sks.naruto-loop-worker-routes.v1',
         mission_id: input.plan.mission_id,
         active_worker_budget: activeWorkerBudget,
+        loop_concurrency_budget: loopConcurrencyBudget,
         routes
     });
     return runLoopPlan({

package/dist/core/proof/auto-finalize.js

@@ -13,7 +13,7 @@ const AGENT_ARTIFACTS = [
     'agents/agent-task-board.json',
     'agents/agent-concurrency-policy.json'
 ];
-export async function maybeFinalizeRoute(root, { missionId, route, gateFile = null, gate = null, artifacts = [], claims = [], visualEvidence = null, visual = false, fixClaim = false, requireRelation = false, mock = false, statusHint = null, reason = null, command = null, dbEvidence = null, testEvidence = null, blockers = [], unverified = [], agents = undefined, allowActiveWrongnessPartial = false } = {}) {
+export async function maybeFinalizeRoute(root, { missionId, route, gateFile = null, gate = null, artifacts = [], claims = [], visualEvidence = null, visual = false, fixClaim = false, requireRelation = false, mock = false, statusHint = null, reason = null, command = null, dbEvidence = null, testEvidence = null, blockers = [], unverified = [], agents = undefined, allowActiveWrongnessPartial = false, failureAnalysis = null } = {}) {
     if (!missionId || !route) {
         return { ok: false, skipped: true, reason: 'mission_id_or_route_missing' };
     }
@@ -61,7 +61,8 @@ export async function maybeFinalizeRoute(root, { missionId, route, gateFile = nu
         requireRelation,
         visualClaim: visual,
         agents,
-        allowActiveWrongnessPartial
+        allowActiveWrongnessPartial,
+        failureAnalysis
     });
     return { ...proof, auto_finalized: true, gate_passed: passed, status_hint: finalStatus };
 }

package/dist/core/proof/route-finalizer.js

@@ -6,7 +6,7 @@ import { readAgentProofEvidence } from '../agents/agent-proof-evidence.js';
 import { wrongnessProofEvidence } from '../triwiki-wrongness/wrongness-proof-linker.js';
 import { computerUseStatusReport } from '../computer-use-status.js';
 import { readComputerUseLiveEvidence } from '../computer-use-live-evidence.js';
-export async function finalizeRouteWithProof(root, { missionId, route, gateFile = null, gate = null, artifacts = [], visualEvidence = null, dbEvidence = null, madSksEvidence = null, testEvidence = null, commandEvidence = null, claims = [], unverified = [], blockers = [], statusHint = 'verified_partial', strict = false, mock = false, fixClaim = false, requireRelation = false, visualClaim = undefined, agents = undefined, allowActiveWrongnessPartial = false } = {}) {
+export async function finalizeRouteWithProof(root, { missionId, route, gateFile = null, gate = null, artifacts = [], visualEvidence = null, dbEvidence = null, madSksEvidence = null, testEvidence = null, commandEvidence = null, claims = [], unverified = [], blockers = [], statusHint = 'verified_partial', strict = false, mock = false, fixClaim = false, requireRelation = false, visualClaim = undefined, agents = undefined, allowActiveWrongnessPartial = false, failureAnalysis = null } = {}) {
     const policy = routeFinalizerPolicy(route, { strict, fixClaim, requireRelation, visualClaim });
     const localBlockers = [...blockers];
     const providedVisualEvidence = visualEvidence;
@@ -66,6 +66,24 @@ export async function finalizeRouteWithProof(root, { missionId, route, gateFile
         ? (strict ? 'blocked' : statusHint === 'verified' ? 'verified_partial' : statusHint)
         : visualComputerUseDowngrade ? 'verified_partial'
             : statusHint;
+    const finalUnverified = [
+        ...unverified,
+        ...(imageEvidence?.mock ? ['Image voxel evidence is mock fixture evidence and does not claim a real visual run.'] : []),
+        ...(Number(wrongnessEvidence?.medium_severity_active || 0) > 0 ? ['Active medium-severity wrongness memory remains and prevents full verification claims.'] : [])
+    ];
+    const resolvedFailureAnalysis = failureAnalysis || inferRouteFailureAnalysis({
+        missionId,
+        route: policy.route,
+        status,
+        blockers: localBlockers,
+        unverified: finalUnverified,
+        wrongnessEvidence,
+        imageEvidence,
+        agentEvidence,
+        computerUse,
+        computerUseLive,
+        visualComputerUseDowngrade
+    });
     const evidence = {
         ...collected,
         ...(dbEvidence ? { db: dbEvidence } : {}),
@@ -109,12 +127,9 @@ export async function finalizeRouteWithProof(root, { missionId, route, gateFile
         artifacts,
         evidence,
         claims,
-        unverified: [
-            ...unverified,
-            ...(imageEvidence?.mock ? ['Image voxel evidence is mock fixture evidence and does not claim a real visual run.'] : []),
-            ...(Number(wrongnessEvidence?.medium_severity_active || 0) > 0 ? ['Active medium-severity wrongness memory remains and prevents full verification claims.'] : [])
-        ],
+        unverified: finalUnverified,
         blockers: localBlockers,
+        failureAnalysis: resolvedFailureAnalysis,
         summary: {
             files_changed: collected.files?.length || 0,
             commands_run: evidence.commands?.length || 0,
@@ -124,4 +139,54 @@ export async function finalizeRouteWithProof(root, { missionId, route, gateFile
         }
     });
 }
+function inferRouteFailureAnalysis({ missionId, route, status, blockers, unverified, wrongnessEvidence, imageEvidence, agentEvidence, computerUse, computerUseLive, visualComputerUseDowngrade } = {}) {
+    if (status === 'verified' && !blockers?.length && !unverified?.length)
+        return null;
+    const evidence = [
+        missionId ? `.sneakoscope/missions/${missionId}/completion-proof.json#unverified` : 'completion-proof.json#unverified',
+        ...(wrongnessEvidence?.mission_ledger ? [wrongnessEvidence.mission_ledger] : []),
+        ...(agentEvidence ? [missionId ? `.sneakoscope/missions/${missionId}/agents/agent-proof-evidence.json` : 'agents/agent-proof-evidence.json'] : []),
+        ...(imageEvidence?.ledger ? ['image_voxels'] : []),
+        ...(computerUse ? ['computer_use_status'] : []),
+        ...(computerUseLive?.path ? [computerUseLive.path] : [])
+    ];
+    if (blockers?.length) {
+        return {
+            status: 'complete',
+            root_cause: `Route ${route || 'unknown'} could not be fully verified because finalization recorded blocking conditions: ${blockers.join(', ')}.`,
+            corrective_action: 'Preserved the non-verified completion status, recorded blockers in Completion Proof, and linked the available route evidence instead of claiming full completion.',
+            evidence
+        };
+    }
+    if (Number(wrongnessEvidence?.medium_severity_active || 0) > 0) {
+        return {
+            status: 'complete',
+            root_cause: `Route ${route || 'unknown'} remains verified_partial because active medium-severity wrongness memory is still present even though no high-severity blocker remains.`,
+            corrective_action: 'Kept the Completion Proof at verified_partial, recorded the wrongness caveat in unverified evidence, and avoided a full verified claim until the memory is resolved or explicitly accepted.',
+            evidence
+        };
+    }
+    if (visualComputerUseDowngrade) {
+        return {
+            status: 'complete',
+            root_cause: 'Native Computer Use visual confidence was downgraded because live capture or Image Voxel linkage was unavailable or incomplete.',
+            corrective_action: 'Kept the Completion Proof at verified_partial and recorded the missing native visual evidence instead of claiming high-confidence visual verification.',
+            evidence
+        };
+    }
+    if (imageEvidence?.mock) {
+        return {
+            status: 'complete',
+            root_cause: 'Visual evidence was produced from a mock fixture, which cannot support a real fully verified visual route claim.',
+            corrective_action: 'Kept the Completion Proof at verified_partial and recorded the mock-evidence caveat in unverified evidence.',
+            evidence
+        };
+    }
+    return {
+        status: 'complete',
+        root_cause: `Route ${route || 'unknown'} generated a non-verified completion status because unresolved caveats remained in final unverified evidence.`,
+        corrective_action: 'Recorded those caveats in Completion Proof and preserved the partial status instead of upgrading the route to verified.',
+        evidence
+    };
+}
 //# sourceMappingURL=route-finalizer.js.map

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

@@ -10,6 +10,7 @@ import { countReleaseGateResources, defaultReleaseGateBudget, summarizeReleaseGa
 import { selectAffectedReleaseGates } from './release-gate-affected-selector.js';
 import { guardedProcessKill, guardContextForRoute } from '../safety/mutation-guard.js';
 import { createRequestedScopeContract } from '../safety/requested-scope-contract.js';
+import { rmrf } from '../fsx.js';
 export function loadReleaseGateManifest(root, file = 'release-gates.v2.json') {
     const manifestPath = path.join(root, file);
     const parsed = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
@@ -33,9 +34,11 @@ export async function runReleaseGateDag(input) {
         ? new Set(selected.flatMap((gate) => gate.deps || []).filter((dep) => !selectedIds.has(dep)))
         : new Set();
     const runId = `rg-${new Date().toISOString().replace(/[:.]/g, '-')}-${process.pid}`;
+    const retentionBefore = await pruneOldReleaseGateRunDirs(root);
     const reportDir = path.join(root, '.sneakoscope', 'reports', 'release-gates', runId);
     fs.mkdirSync(reportDir, { recursive: true });
     const timeline = path.join(reportDir, 'timeline.jsonl');
+    appendReleaseGateJsonl(timeline, { event: 'retention', phase: 'before_run', ...retentionBefore, at: new Date().toISOString() });
     const started = Date.now();
     const pending = new Map(selected.map((gate) => [gate.id, gate]));
     const running = new Map();
@@ -166,7 +169,11 @@ export async function runReleaseGateDag(input) {
         writeSummarySnapshot(false);
     }
     const result = writeSummarySnapshot(true);
-    return result;
+    const retentionAfter = await pruneOldReleaseGateRunDirs(root, { preserveRunId: runId });
+    const finalResult = { ...result, retention: mergeReleaseGateRetention(retentionBefore, retentionAfter) };
+    appendReleaseGateJsonl(timeline, { event: 'retention', phase: 'after_run', ...retentionAfter, at: new Date().toISOString() });
+    writeReleaseGateJson(path.join(reportDir, 'summary.json'), finalResult);
+    return finalResult;
 }
 export function selectReleaseGatePreset(manifest, preset) {
     const effectivePreset = preset === 'affected' || preset === 'fast' ? 'release' : preset;
@@ -258,4 +265,52 @@ function estimateCriticalPath(gates, completed) {
 function tail(value, limit = 1200) {
     return value.length > limit ? value.slice(-limit) : value;
 }
+export async function pruneOldReleaseGateRunDirs(root, opts = {}) {
+    const keep = Math.max(1, Math.floor(Number(opts.keep ?? process.env.SKS_RELEASE_GATE_RUN_RETENTION ?? 20) || 20));
+    const preserveRunId = opts.preserveRunId || null;
+    const base = path.join(root, '.sneakoscope', 'reports', 'release-gates');
+    const report = {
+        schema: 'sks.release-gate-run-retention.v1',
+        keep,
+        scanned: 0,
+        kept: 0,
+        removed: 0,
+        preserve_run_id: preserveRunId,
+        removed_run_ids: []
+    };
+    if (!fs.existsSync(base))
+        return report;
+    const runs = fs.readdirSync(base, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && /^rg-\d{4}-/.test(entry.name))
+        .map((entry) => {
+        const dir = path.join(base, entry.name);
+        const summary = path.join(dir, 'summary.json');
+        const stat = fs.statSync(fs.existsSync(summary) ? summary : dir);
+        return { id: entry.name, dir, mtimeMs: stat.mtimeMs };
+    })
+        .sort((a, b) => b.mtimeMs - a.mtimeMs);
+    report.scanned = runs.length;
+    const keepIds = new Set(runs.slice(0, keep).map((run) => run.id));
+    if (preserveRunId)
+        keepIds.add(preserveRunId);
+    for (const run of runs) {
+        if (keepIds.has(run.id)) {
+            report.kept += 1;
+            continue;
+        }
+        await rmrf(run.dir);
+        report.removed += 1;
+        report.removed_run_ids.push(run.id);
+    }
+    return report;
+}
+function mergeReleaseGateRetention(before, after) {
+    return {
+        ...after,
+        scanned: Math.max(before.scanned, after.scanned),
+        kept: after.kept,
+        removed: before.removed + after.removed,
+        removed_run_ids: [...before.removed_run_ids, ...after.removed_run_ids]
+    };
+}
 //# sourceMappingURL=release-gate-dag.js.map

package/dist/core/version.js

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

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

@@ -89,7 +89,7 @@ export async function runLoopDirectiveCheck(id) {
         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('loopFixtureAllowed'), 'fixture runtime has an explicit test-context allow guard');
+        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');