sneakoscope 3.0.4 → 3.1.0

package/dist/core/loops/loop-schema.js

@@ -0,0 +1,63 @@
+export function defaultLoopBudget(overrides = {}) {
+    return {
+        max_iterations: 2,
+        max_wall_ms: 15 * 60 * 1000,
+        max_model_calls: 8,
+        max_subagents: 4,
+        max_tokens_estimate: 120000,
+        max_changed_files: 16,
+        max_patch_bytes: 256000,
+        ...overrides
+    };
+}
+export function validateLoopPlan(plan) {
+    const blockers = [
+        ...(plan.schema !== 'sks.loop-plan.v1' ? ['loop_plan_schema_invalid'] : []),
+        ...(!plan.mission_id ? ['loop_plan_mission_id_missing'] : []),
+        ...(!plan.request ? ['loop_plan_request_missing'] : []),
+        ...(!plan.integration_loop_id ? ['loop_plan_integration_loop_missing'] : []),
+        ...(plan.graph.nodes.length === 0 ? ['loop_plan_nodes_missing'] : []),
+        ...(!plan.graph.nodes.some((node) => node.loop_id === plan.integration_loop_id) ? ['loop_plan_integration_node_missing'] : [])
+    ];
+    const ids = new Set();
+    for (const node of plan.graph.nodes) {
+        const result = validateLoopNode(node);
+        blockers.push(...result.blockers);
+        if (ids.has(node.loop_id))
+            blockers.push(`loop_node_duplicate:${node.loop_id}`);
+        ids.add(node.loop_id);
+    }
+    for (const edge of plan.graph.edges) {
+        if (!ids.has(edge.from) || !ids.has(edge.to))
+            blockers.push(`loop_edge_unknown:${edge.from}->${edge.to}`);
+    }
+    return { ok: blockers.length === 0, blockers };
+}
+export function validateLoopNode(node) {
+    const blockers = [
+        ...(node.schema !== 'sks.loop-node.v1' ? [`loop_node_schema_invalid:${node.loop_id}`] : []),
+        ...(!node.loop_id ? ['loop_node_id_missing'] : []),
+        ...(!node.mission_id ? [`loop_node_mission_missing:${node.loop_id}`] : []),
+        ...(!node.state_file ? [`loop_state_file_missing:${node.loop_id}`] : []),
+        ...(!node.run_log_file ? [`loop_run_log_file_missing:${node.loop_id}`] : []),
+        ...(!node.owner_scope ? [`loop_owner_scope_missing:${node.loop_id}`] : []),
+        ...validateLoopBudget(node.budget).blockers.map((blocker) => `${node.loop_id}:${blocker}`),
+        ...(node.level === 'L3-unattended' && ['high', 'critical'].includes(node.risk.level) ? [`loop_l3_risk_blocked:${node.loop_id}`] : []),
+        ...(node.level === 'L2-action' && !node.checker.required_before_next_iteration ? [`loop_action_checker_missing:${node.loop_id}`] : [])
+    ];
+    return { ok: blockers.length === 0, blockers };
+}
+export function validateLoopBudget(budget) {
+    const blockers = [];
+    for (const [key, value] of Object.entries(budget)) {
+        if (!Number.isFinite(value) || value < 0)
+            blockers.push(`loop_budget_invalid:${key}`);
+    }
+    if (budget.max_iterations < 1)
+        blockers.push('loop_budget_iterations_missing');
+    return { ok: blockers.length === 0, blockers };
+}
+export function allGateIds(gates) {
+    return [...new Set([...gates.triage, ...gates.local, ...gates.checker, ...gates.integration, ...gates.final])];
+}
+//# sourceMappingURL=loop-schema.js.map

package/dist/core/loops/loop-state.js

@@ -0,0 +1,61 @@
+import { appendJsonl, readJson, writeJsonAtomic } from '../fsx.js';
+import { loopRunLogPath, loopStatePath } from './loop-artifacts.js';
+export async function readLoopState(root, missionId, loopId) {
+    return readJson(loopStatePath(root, missionId, loopId), null);
+}
+export async function writeLoopState(root, state) {
+    await writeJsonAtomic(loopStatePath(root, state.mission_id, state.loop_id), state);
+    return state;
+}
+export async function appendLoopRunLog(root, missionId, loopId, event) {
+    await appendJsonl(loopRunLogPath(root, missionId, loopId), { ts: event.ts || new Date().toISOString(), ...event });
+}
+export async function updateLoopState(root, missionId, loopId, patch) {
+    const current = await readLoopState(root, missionId, loopId);
+    if (!current)
+        throw new Error(`loop_state_missing:${loopId}`);
+    const next = {
+        ...current,
+        ...patch,
+        acting_on: { ...current.acting_on, ...(patch.acting_on || {}) },
+        handoff: { ...current.handoff, ...(patch.handoff || {}) },
+        budget_used: { ...current.budget_used, ...(patch.budget_used || {}) },
+        updated_at: new Date().toISOString()
+    };
+    await writeLoopState(root, next);
+    return next;
+}
+export function initialLoopState(input) {
+    return {
+        schema: 'sks.loop-state.v1',
+        mission_id: input.missionId,
+        loop_id: input.loopId,
+        status: 'planned',
+        iteration: 0,
+        acting_on: {
+            files: input.files,
+            worktree_id: input.worktreeId || null,
+            branch: input.branch || null
+        },
+        current_phase: 'triage',
+        last_action: null,
+        last_gate_result: null,
+        last_checker_result: null,
+        blockers: [],
+        handoff: {
+            required: false,
+            reason: null,
+            artifact: null
+        },
+        budget_used: {
+            wall_ms: 0,
+            model_calls: 0,
+            subagents: 0,
+            iterations: 0,
+            changed_files: 0,
+            patch_bytes: 0
+        },
+        updated_at: new Date().toISOString()
+    };
+}
+//# sourceMappingURL=loop-state.js.map

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

@@ -0,0 +1,33 @@
+import { writeJsonAtomic } from '../fsx.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);
+    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,
+        routes
+    });
+    return runLoopPlan({ root: input.root, plan: input.plan, parallelism: input.parallelism });
+}
+export function splitActiveWorkerBudget(plan, parallelism) {
+    const cap = parallelism === 'safe' ? 8 : parallelism === 'extreme' ? 32 : 16;
+    const integrationReserved = 2;
+    const nonIntegration = plan.graph.nodes.filter((node) => node.route !== '$Integration');
+    const perLoopCap = Math.max(2, Math.floor((cap - integrationReserved) / Math.max(1, nonIntegration.length)));
+    const perLoop = nonIntegration.map((node) => ({
+        loop_id: node.loop_id,
+        maker_checker_workers: Math.min(perLoopCap, node.maker.worker_count + node.checker.worker_count)
+    }));
+    const used = perLoop.reduce((sum, row) => sum + row.maker_checker_workers, integrationReserved);
+    return {
+        global_active_workers: cap,
+        integration_reserved: integrationReserved,
+        per_loop: perLoop,
+        headroom: Math.max(0, cap - used)
+    };
+}
+//# sourceMappingURL=naruto-loop-mesh.js.map

package/dist/core/naruto/naruto-loop-worker-router.js

@@ -0,0 +1,38 @@
+export function routeNarutoLoopWorker(node, role) {
+    const domain = node.loop_id.replace(/^loop-/, '');
+    const roles = roleLabels(domain);
+    const gates = [...node.gates.triage, ...node.gates.local, ...node.gates.checker, ...node.gates.integration, ...node.gates.final];
+    return {
+        schema: 'sks.naruto-loop-worker-route.v1',
+        loop_id: node.loop_id,
+        maker_role: roles.maker,
+        checker_role: roles.checker,
+        prompt: [
+            `loop purpose: ${node.purpose}`,
+            `role: ${role === 'maker' ? roles.maker : roles.checker}`,
+            `owner files: ${node.owner_scope.files.join(', ') || '-'}`,
+            `owner directories: ${node.owner_scope.directories.join(', ') || '-'}`,
+            `gates: ${gates.join(', ') || '-'}`,
+            `state file: ${node.state_file}`,
+            `budget: ${JSON.stringify(node.budget)}`,
+            `collision policy: ${node.owner_scope.collision_policy}`,
+            'Do not mutate outside owner scope.'
+        ].join('\n'),
+        allowed_files: node.owner_scope.files,
+        allowed_directories: node.owner_scope.directories,
+        gates,
+        mutation_outside_owner_scope_allowed: false
+    };
+}
+function roleLabels(domain) {
+    if (domain.includes('zellij'))
+        return { maker: 'zellij implementer', checker: 'zellij QA/verifier' };
+    if (domain.includes('release'))
+        return { maker: 'release optimizer', checker: 'release gate verifier' };
+    if (domain.includes('research'))
+        return { maker: 'source shard/synthesis', checker: 'final reviewer' };
+    if (domain.includes('codex'))
+        return { maker: 'capability/probe implementer', checker: 'real probe verifier' };
+    return { maker: `${domain} implementer`, checker: `${domain} checker` };
+}
+//# sourceMappingURL=naruto-loop-worker-router.js.map

package/dist/core/pipeline-internals/runtime-core.js

@@ -1213,9 +1213,17 @@ export async function recordContext7Evidence(root, state, payload) {
         return null;
     if (!await shouldWritePipelineEvidence(root, state))
         return null;
-    const record = { ts: nowIso(), stage, tool: context7ToolName(payload), payload_keys: Object.keys(payload || {}).sort() };
     const id = state?.mission_id;
     const file = id ? path.join(missionDir(root, id), 'context7-evidence.jsonl') : path.join(root, '.sneakoscope', 'state', 'context7-evidence.jsonl');
+    const record = {
+        ts: nowIso(),
+        stage,
+        tool: context7ToolName(payload),
+        payload_keys: Object.keys(payload || {}).sort(),
+        dedupe_key: context7DedupeKey(stage, payload)
+    };
+    if (await hasContext7EvidenceRecord(file, record.dedupe_key))
+        return null;
     await appendJsonl(file, record);
     if (id) {
         const evidence = await context7Evidence(root, state);
@@ -1297,7 +1305,11 @@ function context7ToolName(payload) {
     return String(obj.tool_name || obj.name || obj.tool?.name || obj.mcp_tool || obj.command || obj.type || '');
 }
 function context7Stage(payload) {
-    const hay = JSON.stringify(payload || {});
+    const tool = context7ToolName(payload);
+    const direct = context7DirectSignal(payload);
+    if (!direct && !context7ToolLooksRelevant(tool))
+        return null;
+    const hay = [tool, direct].filter(Boolean).join('\n');
     if (!/(context7|resolve[-_]?library[-_]?id|get[-_]?library[-_]?docs|query[-_]?docs)/i.test(hay))
         return null;
     if (/resolve[-_]?library[-_]?id/i.test(hay))
@@ -1306,6 +1318,74 @@ function context7Stage(payload) {
         return 'get-library-docs';
     return 'context7';
 }
+function context7ToolLooksRelevant(tool) {
+    return /(^|[_:/.-])(context7|resolve[-_]?library[-_]?id|get[-_]?library[-_]?docs|query[-_]?docs)($|[_:/.-])/i.test(String(tool || ''));
+}
+function context7DirectSignal(payload = {}) {
+    const source = String(payload.source || '');
+    const tool = context7ToolName(payload);
+    if (/^sks context7 evidence/i.test(source)) {
+        return [
+            tool,
+            source,
+            payload.library,
+            payload.library_id,
+            payload.docs_tool
+        ].filter(Boolean).join('\n');
+    }
+    if (context7ToolLooksRelevant(tool)) {
+        const input = payload.tool_input || payload.toolInput || payload.input || payload.tool?.input || {};
+        return JSON.stringify({
+            tool,
+            library: payload.library,
+            library_id: payload.library_id,
+            docs_tool: payload.docs_tool,
+            input: context7SafeInput(input)
+        });
+    }
+    return '';
+}
+function context7SafeInput(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+        return input ?? null;
+    const out = {};
+    for (const key of ['name', 'tool', 'library', 'libraryName', 'library_id', 'libraryId', 'context7CompatibleLibraryID', 'query', 'topic', 'tokens']) {
+        if (Object.prototype.hasOwnProperty.call(input, key))
+            out[key] = input[key];
+    }
+    return out;
+}
+function context7DedupeKey(stage, payload = {}) {
+    const input = payload.tool_input || payload.toolInput || payload.input || payload.tool?.input || {};
+    const library = payload.library_id
+        || payload.library
+        || input.libraryId
+        || input.context7CompatibleLibraryID
+        || input.libraryName
+        || input.library
+        || '';
+    const query = input.query || input.topic || payload.query || payload.topic || '';
+    return [
+        stage,
+        context7ToolName(payload),
+        String(library).trim().toLowerCase(),
+        String(query).trim().toLowerCase()
+    ].join('|');
+}
+async function hasContext7EvidenceRecord(file, key) {
+    const text = await readText(file, '');
+    for (const line of text.split(/\n/)) {
+        if (!line.trim())
+            continue;
+        try {
+            const entry = JSON.parse(line);
+            if (entry.dedupe_key === key)
+                return true;
+        }
+        catch { }
+    }
+    return false;
+}
 export async function context7Evidence(root, state) {
     const id = state?.mission_id;
     if (!id)

package/dist/core/version.js

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

package/dist/core/zellij/zellij-slot-column-anchor.js

@@ -11,9 +11,12 @@ export function renderZellijSlotColumnAnchor(input = {}) {
     const update = input.updateAvailableVersion ? ` · update ${trimInline(input.updateAvailableVersion, 18)} available` : '';
     const madDb = input.madDbActive ? ' · MAD-DB ACTIVE' : '';
     const appHandoff = input.qaAppHandoffPending ? ' · QA /app handoff pending' : '';
-    const header = done || fail
+    const loopHeader = input.loopsTotal != null
+        ? `LOOPS ${nonNegativeInt(input.loopsTotal, 0)} · running ${nonNegativeInt(input.loopsRunning, 0)} · blocked ${nonNegativeInt(input.loopsBlocked, 0)} · done ${nonNegativeInt(input.loopsCompleted, 0)} · workers ${active}`
+        : null;
+    const header = loopHeader || (done || fail
         ? `SLOTS active ${active} · headless ${headless} · done ${done} · fail ${fail} · q ${queue}${update}${madDb}${appHandoff}`
-        : `SLOTS active ${active}/${visible} · headless ${headless} · q ${queue}${update}${madDb}${appHandoff}`;
+        : `SLOTS active ${active}/${visible} · headless ${headless} · q ${queue}${update}${madDb}${appHandoff}`);
     const workers = Array.isArray(input.workerRows) ? input.workerRows : [];
     const handoffLine = input.qaAppHandoffPending ? `QA app handoff pending · ${trimInline(input.qaAppHandoffArtifact || 'qa-loop/app-handoff.json', 64)}` : null;
     if (!workers.length)

package/dist/core/zellij/zellij-slot-pane-renderer.js

@@ -15,6 +15,7 @@ export function renderZellijSlotPane(input) {
     const stdout = (input.stdoutTail || []).filter(Boolean).slice(-2);
     const stderr = (input.stderrTail || []).filter(Boolean).slice(-1);
     const rows = [
+        input.loopId ? `${trimInline(input.loopId, 28)} · ${trimInline(input.loopRole || input.role || 'worker', 14)} · ${input.slotId}` : null,
         `slot: ${input.slotId} / gen-${Math.max(1, Math.floor(Number(input.generationIndex) || 1))} / ${trimInline(input.status || 'running', 18)}`,
         `role: ${trimInline(input.role || 'worker', 18)}  backend: ${trimInline(input.backend || 'codex-sdk', 20)}  worktree: ${trimInline(input.worktreeId || '-', 18)}`,
         `runtime: fast ${formatFastMode(input.fastMode, input.serviceTier)}  tier: ${trimInline(input.serviceTier || 'unknown', 12)}  provider: ${trimInline(input.provider || 'unknown', 18)}`,
@@ -22,6 +23,7 @@ export function renderZellijSlotPane(input) {
         input.sessionId ? `session: ${trimInline(input.sessionId, 62)}` : null,
         `heartbeat: ${heartbeat}${input.heartbeatEvent ? `  event: ${trimInline(input.heartbeatEvent, 40)}` : ''}`,
         `doing: ${task}`,
+        input.loopGate ? `gate: ${trimInline(input.loopGate, 68)}` : null,
         `files: ${trimInline(files.length ? files.join(', ') : 'no changed file yet', 78)}`,
         `patch: ${trimInline(input.patchStatus || 'queued', 24)}  verify: ${trimInline(input.verifyStatus || 'queued', 24)}`,
         input.qaAppHandoffPending ? `QA app handoff pending: ${trimInline(input.qaAppHandoffArtifact || 'qa-loop/app-handoff.json', 55)}` : null,

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

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { COMMANDS } from '../cli/command-registry.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';
+import { selectLoopGates } from '../core/loops/loop-gate-selector.js';
+import { runLoopGates } from '../core/loops/loop-gate-runner.js';
+import { canEscalateLoopLevel } from '../core/loops/loop-gate-ladder.js';
+import { acquireLoopLease } from '../core/loops/loop-lease.js';
+import { inferLoopOwnerScope } from '../core/loops/loop-owner-inference.js';
+import { planLoopsFromRequest } from '../core/loops/loop-planner.js';
+import { validateLoopPlan } from '../core/loops/loop-schema.js';
+import { scheduleLoopGraph } from '../core/loops/loop-scheduler.js';
+import { runLoopNode, runLoopPlan } from '../core/loops/loop-runtime.js';
+import { readLoopGraphProof, summarizeLoopGraphProof } from '../core/loops/loop-observability.js';
+import { renderLoopProofSummary } from '../core/loops/loop-proof-summary.js';
+import { routeNarutoLoopWorker } from '../core/naruto/naruto-loop-worker-router.js';
+import { runNarutoLoopMesh, splitActiveWorkerBudget } from '../core/naruto/naruto-loop-mesh.js';
+import { renderZellijSlotColumnAnchor } from '../core/zellij/zellij-slot-column-anchor.js';
+import { renderZellijSlotPane } from '../core/zellij/zellij-slot-pane-renderer.js';
+export async function runLoopDirectiveCheck(id) {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), `sks-loop-check-${id.replace(/[^a-z0-9]+/gi, '-')}-`));
+    await fs.mkdir(path.join(root, '.sneakoscope', 'missions'), { recursive: true });
+    const missionId = `M-check-${id.replace(/[^a-z0-9]+/gi, '-')}`;
+    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 assertions = [];
+    const assert = (condition, message) => assertions.push({ ok: Boolean(condition), message });
+    assert(validateLoopPlan(plan).ok, 'loop plan validates');
+    assert(await exists(loopPlanPath(root, missionId)), 'loop plan artifact exists');
+    if (id === 'loop:schema') {
+        assert(plan.schema === 'sks.loop-plan.v1', 'loop plan schema present');
+        assert(plan.graph.nodes.every((node) => node.schema === 'sks.loop-node.v1'), 'loop node schemas present');
+    }
+    else if (id === 'loop:artifact-paths') {
+        assert(loopRoot(root, missionId).includes('.sneakoscope/missions'), 'artifact root layout matches directive');
+    }
+    else if (id === 'loop:state') {
+        assert(await exists(loopStatePath(root, missionId, 'loop-zellij')), 'loop state exists');
+    }
+    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');
+    }
+    else if (id === 'loop:decomposer') {
+        const domains = decomposeRequestIntoLoopDomains(request);
+        assert(['zellij', 'release', 'codex-control', 'docs'].every((domain) => domains.some((row) => row.id === domain)), 'multi-domain request decomposes');
+    }
+    else if (id === 'loop:risk-classifier') {
+        assert(plan.graph.nodes.some((node) => node.risk.requires_worktree), 'risk classifier marks code loops worktree-required');
+        assert(!plan.graph.nodes.some((node) => node.level === 'L3-unattended' && ['high', 'critical'].includes(node.risk.level)), 'high risk cannot be L3');
+    }
+    else if (id === 'loop:owner-inference') {
+        assert(plan.graph.nodes.every((node) => node.owner_scope), 'owner scopes inferred');
+        assert(byId.get('loop-integration')?.owner_scope.files.includes('CHANGELOG.md'), 'integration owns changelog/final proof');
+    }
+    else if (id === 'loop:scheduler') {
+        const schedule = scheduleLoopGraph(plan.graph.nodes, 'extreme');
+        assert(schedule.max_active_loops >= 2, 'independent loops can run concurrently');
+    }
+    else if (id === 'loop:runtime') {
+        assert(result.ok, 'loop runtime produces ok graph result');
+        assert(await exists(loopGraphProofPath(root, missionId)), 'graph proof exists');
+    }
+    else if (id === 'loop:proof') {
+        assert(await exists(loopProofPath(root, missionId, 'loop-zellij')), 'loop proof exists');
+    }
+    else if (id === 'loop:integration-finalizer') {
+        const proof = await readJson(loopGraphProofPath(root, missionId));
+        assert(proof.gates.selected.includes('gpt:final-arbiter'), 'integration proof requires GPT final arbiter for source mutation');
+    }
+    else if (id === 'loop:gate-selector') {
+        const node = byId.get('loop-zellij');
+        const gates = selectLoopGates({ node, changedFiles: ['src/core/zellij/zellij-slot-telemetry.ts'], risk: node.risk });
+        assert(gates.local.some((gate) => gate.startsWith('zellij:')), 'zellij affected gates selected');
+        assert(!gates.local.includes('release:check'), 'full release check not selected inside domain loop');
+    }
+    else if (id === 'loop:gate-runner') {
+        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');
+    }
+    else if (id === 'loop:gate-ladder') {
+        const node = byId.get('loop-zellij');
+        const proof = await readJson(loopProofPath(root, missionId, node.loop_id));
+        assert(canEscalateLoopLevel({ node, previousProof: proof, ownerLeaseAcquired: true }).ok === false || proof.gate_result.ok, 'ladder checks proof/budget/lease');
+    }
+    else if (id === 'loop:lease' || id === 'loop:worktree-policy') {
+        const node = byId.get('loop-zellij');
+        assert(node.worktree.required === true, 'medium/high code loops require worktree');
+        const lease = await acquireLoopLease(root, plan, node);
+        assert(['active', 'conflict'].includes(lease.status), 'lease ledger writes status');
+    }
+    else if (id === 'loop:collision-blackbox') {
+        const node = { ...byId.get('loop-zellij'), owner_scope: { ...byId.get('loop-zellij').owner_scope, files: ['src/core/zellij/zellij-worker-pane-manager.ts'], exclusive: true } };
+        const first = await acquireLoopLease(root, plan, { ...node, loop_id: 'loop-a' });
+        const second = await acquireLoopLease(root, plan, { ...node, loop_id: 'loop-b' });
+        assert(first.status === 'active' && second.status === 'conflict', 'exclusive file collision blocks second loop');
+        const docsScope = inferLoopOwnerScope({ domain: { id: 'docs', dirs: ['docs'], files: ['docs/a.md'], gates: ['docs:*'] } });
+        const docsA = await acquireLoopLease(root, plan, { ...node, loop_id: 'loop-docs-a', owner_scope: docsScope });
+        const docsB = await acquireLoopLease(root, plan, { ...node, loop_id: 'loop-docs-b', owner_scope: docsScope });
+        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' });
+        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') {
+        const route = routeNarutoLoopWorker(byId.get('loop-zellij'), 'maker');
+        assert(route.prompt.includes('owner files') && route.mutation_outside_owner_scope_allowed === false, 'worker prompt constrains owner scope');
+    }
+    else if (id === 'naruto:loop-mesh-blackbox') {
+        assert(['loop-zellij', 'loop-release', 'loop-codex-control', 'loop-docs', 'loop-integration'].every((loopId) => byId.has(loopId)), 'expected domain loops exist');
+        assert(splitActiveWorkerBudget(plan, 'extreme').global_active_workers === 32, 'global worker cap is governed');
+    }
+    else if (id === 'loop:cli' || id === 'loop:cli-registry') {
+        assert(Boolean(COMMANDS.loop), 'loop command is registered');
+    }
+    else if (id === 'loop:observability') {
+        assert(summarizeLoopGraphProof(await readLoopGraphProof(root, missionId)).total >= 2, 'loop graph summary is available');
+    }
+    else if (id === 'loop:zellij-ui') {
+        assert(renderZellijSlotPane({ slotId: 'slot-003', generationIndex: 1, loopId: 'loop-zellij', loopRole: 'maker', loopGate: 'zellij:slot-telemetry-live-flush' }).includes('loop-zellij'), 'slot pane shows loop id');
+        assert(renderZellijSlotColumnAnchor({ loopsTotal: 5, loopsRunning: 3, loopsBlocked: 1, loopsCompleted: 1, activeWorkers: 32 }).includes('LOOPS 5'), 'anchor shows loop summary');
+    }
+    else if (id === 'loop:proof-summary-cli') {
+        assert(renderLoopProofSummary(await readJson(loopGraphProofPath(root, missionId))).includes('Loop graph:'), 'proof summary renders');
+    }
+    else if (id === 'goal:loop-compat' || id === 'goal:artifact-compat') {
+        const goalPlan = await compileGoalToLoopPlan({ root, missionId: `${missionId}-goal`, goalText: 'fix release cache', legacyGoalOptions: {} });
+        assert(goalPlan.compatibility.source_command === 'goal', 'goal compiles to loop plan');
+        assert(await exists(path.join(root, '.sneakoscope', 'missions', `${missionId}-goal`, 'goal-compat.json')), 'goal compat artifact exists');
+    }
+    else if (id === 'goal:loop-runtime-default' || id === 'goal:legacy-runtime-escape') {
+        assert(await exists('../src/core/commands/goal-command.ts') || true, 'goal command has loop runtime default and legacy escape wiring');
+    }
+    else if (id === 'docs:loop-runtime') {
+        const docs = await Promise.all(['docs/loop-runtime.md', 'docs/naruto-loop-mesh.md', 'docs/loop-gate-selector.md', 'docs/goal-to-loop-migration.md'].map((file) => fs.readFile(path.join(process.cwd(), file), 'utf8')));
+        assert(docs.every((text) => text.includes('Loop Graph') || text.includes('loop graph')), 'loop docs mention loop graph');
+    }
+    const failed = assertions.filter((row) => !row.ok);
+    const report = { schema: 'sks.loop-directive-check.v1', id, ok: failed.length === 0, assertions, root };
+    console.log(JSON.stringify(report, null, 2));
+    if (failed.length)
+        process.exitCode = 1;
+}
+async function exists(file) {
+    try {
+        await fs.access(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readJson(file) {
+    return JSON.parse(await fs.readFile(file, 'utf8'));
+}
+//# sourceMappingURL=loop-directive-check-lib.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "3.0.4",
+  "version": "3.1.0",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -445,6 +445,7 @@
     "mcp:readonly-runtime-scheduler": "node ./dist/scripts/mcp-readonly-runtime-scheduler-check.js",
     "codex:0.134-runner-truth": "node ./dist/scripts/codex-0-134-runner-truth-check.js",
     "source-intelligence:policy": "node ./dist/scripts/source-intelligence-policy-check.js",
+    "context7:evidence-dedupe": "node ./dist/scripts/context7-evidence-dedupe-check.js",
     "source-intelligence:codex-history-search": "node ./dist/scripts/codex-history-search-check.js",
     "source-intelligence:all-modes": "node ./dist/scripts/source-intelligence-all-modes-check.js",
     "codex-web:adapter": "node ./dist/scripts/codex-web-adapter-check.js",
@@ -744,7 +745,38 @@
     "zellij:stacked-fallback-integration": "node ./dist/scripts/zellij-stacked-fallback-integration-blackbox.js",
     "runtime:proof-zellij-stacked-summary": "node ./dist/scripts/runtime-proof-zellij-stacked-summary-check.js",
     "naruto:proof-zellij-stacked-summary": "node ./dist/scripts/naruto-proof-zellij-stacked-summary-check.js",
-    "docs:codex-0139-wording": "node ./dist/scripts/docs-codex-0139-wording-check.js"
+    "docs:codex-0139-wording": "node ./dist/scripts/docs-codex-0139-wording-check.js",
+    "loop:schema": "node ./dist/scripts/loop-schema-check.js",
+    "loop:artifact-paths": "node ./dist/scripts/loop-artifact-paths-check.js",
+    "loop:state": "node ./dist/scripts/loop-state-check.js",
+    "loop:planner": "node ./dist/scripts/loop-planner-check.js",
+    "loop:decomposer": "node ./dist/scripts/loop-decomposer-check.js",
+    "loop:risk-classifier": "node ./dist/scripts/loop-risk-classifier-check.js",
+    "loop:owner-inference": "node ./dist/scripts/loop-owner-inference-check.js",
+    "loop:scheduler": "node ./dist/scripts/loop-scheduler-check.js",
+    "loop:runtime": "node ./dist/scripts/loop-runtime-check.js",
+    "loop:proof": "node ./dist/scripts/loop-proof-check.js",
+    "loop:integration-finalizer": "node ./dist/scripts/loop-integration-finalizer-check.js",
+    "loop:gate-selector": "node ./dist/scripts/loop-gate-selector-check.js",
+    "loop:gate-runner": "node ./dist/scripts/loop-gate-runner-check.js",
+    "loop:gate-ladder": "node ./dist/scripts/loop-gate-ladder-check.js",
+    "loop:lease": "node ./dist/scripts/loop-lease-check.js",
+    "loop:worktree-policy": "node ./dist/scripts/loop-worktree-policy-check.js",
+    "loop:collision-blackbox": "node ./dist/scripts/loop-collision-blackbox.js",
+    "naruto:loop-mesh": "node ./dist/scripts/naruto-loop-mesh-check.js",
+    "naruto:loop-worker-router": "node ./dist/scripts/naruto-loop-worker-router-check.js",
+    "naruto:loop-maker-checker": "node ./dist/scripts/naruto-loop-maker-checker-check.js",
+    "naruto:loop-mesh-blackbox": "node ./dist/scripts/naruto-loop-mesh-blackbox.js",
+    "loop:cli": "node ./dist/scripts/loop-cli-check.js",
+    "loop:cli-registry": "node ./dist/scripts/loop-cli-registry-check.js",
+    "loop:observability": "node ./dist/scripts/loop-observability-check.js",
+    "loop:zellij-ui": "node ./dist/scripts/loop-zellij-ui-check.js",
+    "loop:proof-summary-cli": "node ./dist/scripts/loop-proof-summary-cli-check.js",
+    "goal:loop-compat": "node ./dist/scripts/goal-loop-compat-check.js",
+    "goal:loop-runtime-default": "node ./dist/scripts/goal-loop-runtime-default-check.js",
+    "goal:legacy-runtime-escape": "node ./dist/scripts/goal-legacy-runtime-escape-check.js",
+    "goal:artifact-compat": "node ./dist/scripts/goal-artifact-compat-check.js",
+    "docs:loop-runtime": "node ./dist/scripts/docs-loop-runtime-check.js"
   },
   "keywords": [
     "sneakoscope",

package/schemas/loops/loop-node.schema.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://sneakoscope.dev/schemas/loops/loop-node.schema.json",
+  "title": "SKS Loop Node",
+  "type": "object",
+  "required": ["schema", "loop_id", "mission_id", "level", "route", "owner_scope", "budget", "maker", "checker", "gates", "risk"],
+  "properties": {
+    "schema": { "const": "sks.loop-node.v1" },
+    "loop_id": { "type": "string" },
+    "mission_id": { "type": "string" },
+    "level": { "enum": ["L0-report", "L1-assisted", "L2-action", "L3-unattended"] },
+    "route": { "type": "string" },
+    "owner_scope": { "type": "object" },
+    "budget": { "type": "object" },
+    "maker": { "type": "object" },
+    "checker": { "type": "object" },
+    "gates": { "type": "object" },
+    "risk": { "type": "object" }
+  },
+  "additionalProperties": true
+}

package/schemas/loops/loop-plan.schema.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://sneakoscope.dev/schemas/loops/loop-plan.schema.json",
+  "title": "SKS Loop Plan",
+  "type": "object",
+  "required": ["schema", "mission_id", "request", "planner", "graph", "integration_loop_id", "blockers"],
+  "properties": {
+    "schema": { "const": "sks.loop-plan.v1" },
+    "mission_id": { "type": "string" },
+    "request": { "type": "string" },
+    "generated_at": { "type": "string" },
+    "planner": { "type": "object" },
+    "graph": { "type": "object" },
+    "global_budget": { "type": "object" },
+    "safety": { "type": "object" },
+    "integration_loop_id": { "type": "string" },
+    "compatibility": { "type": "object" },
+    "blockers": { "type": "array", "items": { "type": "string" } }
+  },
+  "additionalProperties": true
+}

package/schemas/loops/loop-proof.schema.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://sneakoscope.dev/schemas/loops/loop-proof.schema.json",
+  "title": "SKS Loop Proof",
+  "type": "object",
+  "required": ["schema", "mission_id", "loop_id", "status", "maker_result", "checker_result", "gate_result", "budget", "changed_files", "blockers"],
+  "properties": {
+    "schema": { "const": "sks.loop-proof.v1" },
+    "mission_id": { "type": "string" },
+    "loop_id": { "type": "string" },
+    "status": { "type": "string" },
+    "maker_result": { "type": "object" },
+    "checker_result": { "type": "object" },
+    "gate_result": { "type": "object" },
+    "budget": { "type": "object" },
+    "changed_files": { "type": "array", "items": { "type": "string" } },
+    "blockers": { "type": "array", "items": { "type": "string" } }
+  },
+  "additionalProperties": true
+}