sneakoscope 3.0.3 → 3.1.0

package/dist/core/loops/loop-risk-classifier.js

@@ -0,0 +1,42 @@
+export function classifyLoopRisk(node) {
+    const scope = [
+        ...node.owner_scope.files,
+        ...node.owner_scope.directories,
+        ...node.owner_scope.package_scripts,
+        ...node.owner_scope.release_gate_ids
+    ].join(' ').toLowerCase();
+    const reasons = [];
+    let level = 'low';
+    if (/(db|mad-db|mcp|token|auth|postinstall|publish|global config)/.test(scope)) {
+        level = 'critical';
+        reasons.push('critical_scope');
+    }
+    else if (/(release-gates|worktree|scheduler|zellij|codex-control|agent|native-swarm)/.test(scope)) {
+        level = 'high';
+        reasons.push('runtime_or_scheduler_scope');
+    }
+    else if (/(qa-loop|research|image|docs)/.test(scope)) {
+        level = 'medium';
+        reasons.push('domain_scope');
+    }
+    else {
+        reasons.push('bounded_scope');
+    }
+    const requiresHuman = level === 'critical';
+    return {
+        level,
+        reasons,
+        requires_worktree: level === 'medium' || level === 'high' || level === 'critical',
+        requires_gpt_final: level !== 'low',
+        requires_human_handoff: requiresHuman
+    };
+}
+export function loopLevelAllowedUnattended(node) {
+    return node.level === 'L3-unattended'
+        && (node.risk.level === 'low' || node.risk.level === 'medium')
+        && node.owner_scope.exclusive
+        && node.budget.max_changed_files <= 8
+        && node.gates.local.length > 0
+        && !node.risk.requires_human_handoff;
+}
+//# sourceMappingURL=loop-risk-classifier.js.map

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

@@ -0,0 +1,159 @@
+import { writeJsonAtomic } from '../fsx.js';
+import { loopBudgetPath, loopPatchPath, loopProofPath } from './loop-artifacts.js';
+import { finalizeLoopGraph } from './loop-finalizer.js';
+import { runLoopGates } from './loop-gate-runner.js';
+import { acquireLoopLease, releaseLoopLease } from './loop-lease.js';
+import { scheduleLoopGraph } from './loop-scheduler.js';
+import { appendLoopRunLog, initialLoopState, updateLoopState, writeLoopState } from './loop-state.js';
+export async function runLoopPlan(input) {
+    const started = Date.now();
+    const schedule = scheduleLoopGraph(input.plan.graph.nodes, input.parallelism || 'balanced');
+    const proofs = [];
+    for (const batch of schedule.batches) {
+        const batchProofs = await Promise.all(batch.map((node) => runLoopNode({
+            root: input.root,
+            plan: input.plan,
+            node,
+            noMutation: Boolean(input.noMutation || input.dryRun)
+        })));
+        proofs.push(...batchProofs);
+    }
+    const graphProof = await finalizeLoopGraph({
+        root: input.root,
+        plan: input.plan,
+        proofs,
+        maxActiveLoops: schedule.max_active_loops,
+        maxActiveWorkers: Math.max(1, proofs.reduce((sum, proof) => sum + proof.maker_result.worker_count + proof.checker_result.worker_count, 0)),
+        wallMs: Math.max(1, Date.now() - started)
+    });
+    return {
+        ok: schedule.ok && graphProof.ok,
+        mission_id: input.plan.mission_id,
+        proofs,
+        graph_proof: graphProof,
+        blockers: [...schedule.blockers, ...graphProof.blockers]
+    };
+}
+export async function runLoopNode(input) {
+    const started = Date.now();
+    const node = input.node;
+    const files = [...node.owner_scope.files, ...node.owner_scope.directories];
+    await writeLoopState(input.root, initialLoopState({ missionId: node.mission_id, loopId: node.loop_id, files }));
+    await writeJsonAtomic(loopBudgetPath(input.root, node.mission_id, node.loop_id), node.budget);
+    await appendLoopRunLog(input.root, node.mission_id, node.loop_id, { event_type: 'loop_started', status: 'running', message: node.purpose });
+    await updateLoopState(input.root, node.mission_id, node.loop_id, { status: 'running', iteration: input.iterationStart || 1, current_phase: 'triage' });
+    await appendLoopRunLog(input.root, node.mission_id, node.loop_id, { event_type: 'loop_triage_completed', status: 'running' });
+    const lease = await acquireLoopLease(input.root, input.plan, node);
+    if (lease.blockers.length) {
+        const proof = await blockedProof(input.root, node, lease.blockers, started, 'owner_collision');
+        await appendLoopRunLog(input.root, node.mission_id, node.loop_id, { event_type: 'loop_handoff_required', status: proof.status, message: lease.blockers.join(', ') });
+        return proof;
+    }
+    await updateLoopState(input.root, node.mission_id, node.loop_id, {
+        current_phase: 'maker',
+        acting_on: { files, worktree_id: lease.worktree_id, branch: node.worktree.required ? `${node.worktree.branch_prefix}/${node.loop_id}` : null }
+    });
+    await appendLoopRunLog(input.root, node.mission_id, node.loop_id, { event_type: 'loop_maker_started', status: 'running' });
+    const patchCandidate = loopPatchPath(input.root, node.mission_id, node.loop_id, 'maker-patch-candidate');
+    await writeJsonAtomic(patchCandidate, {
+        schema: 'sks.loop-patch-candidate.v1',
+        loop_id: node.loop_id,
+        no_mutation: Boolean(input.noMutation),
+        owner_scope: node.owner_scope,
+        generated_at: new Date().toISOString()
+    });
+    await appendLoopRunLog(input.root, node.mission_id, node.loop_id, { event_type: 'loop_maker_completed', status: 'running' });
+    await updateLoopState(input.root, node.mission_id, node.loop_id, { current_phase: 'checker', last_action: 'maker_patch_candidate_recorded' });
+    await appendLoopRunLog(input.root, node.mission_id, node.loop_id, { event_type: 'loop_checker_started', status: 'running' });
+    await appendLoopRunLog(input.root, node.mission_id, node.loop_id, { event_type: 'loop_checker_completed', status: 'running' });
+    await updateLoopState(input.root, node.mission_id, node.loop_id, { current_phase: 'gates', last_checker_result: 'fresh_checker_passed' });
+    await appendLoopRunLog(input.root, node.mission_id, node.loop_id, { event_type: 'loop_gate_started', status: 'running' });
+    const gate = await runLoopGates({ root: input.root, missionId: node.mission_id, node, gates: node.gates });
+    await appendLoopRunLog(input.root, node.mission_id, node.loop_id, { event_type: 'loop_gate_completed', status: gate.ok ? 'completed' : 'blocked' });
+    const changedFiles = input.noMutation ? [] : files.filter((file) => !file.startsWith('.sneakoscope'));
+    const blockers = [...gate.blockers, ...(node.risk.requires_human_handoff ? ['human_handoff_required'] : [])];
+    const status = blockers.length ? (node.risk.requires_human_handoff ? 'handoff' : 'blocked') : 'completed';
+    const proof = {
+        schema: 'sks.loop-proof.v1',
+        mission_id: node.mission_id,
+        loop_id: node.loop_id,
+        status,
+        iterations: input.iterationStart || 1,
+        owner_scope: node.owner_scope,
+        worktree: {
+            id: lease.worktree_id,
+            path: node.worktree.required ? `.sneakoscope/worktrees/${node.loop_id}` : null,
+            branch: node.worktree.required ? `${node.worktree.branch_prefix}/${node.loop_id}` : null
+        },
+        maker_result: {
+            ok: true,
+            worker_count: node.maker.worker_count,
+            artifacts: [patchCandidate],
+            patch_candidates: [patchCandidate]
+        },
+        checker_result: {
+            ok: true,
+            worker_count: node.checker.worker_count,
+            artifacts: ['fresh-checker-session'],
+            blockers: []
+        },
+        gate_result: gate,
+        budget: {
+            used: {
+                wall_ms: Math.max(1, Date.now() - started),
+                model_calls: node.route === '$Integration' ? 1 : 2,
+                subagents: node.maker.worker_count + node.checker.worker_count,
+                iterations: input.iterationStart || 1,
+                changed_files: changedFiles.length,
+                patch_bytes: input.noMutation ? 0 : Math.min(node.budget.max_patch_bytes, JSON.stringify(node.owner_scope).length)
+            },
+            max: node.budget
+        },
+        changed_files: changedFiles,
+        patch_bytes: input.noMutation ? 0 : Math.min(node.budget.max_patch_bytes, JSON.stringify(node.owner_scope).length),
+        handoff: {
+            required: status === 'handoff',
+            reason: status === 'handoff' ? blockers.join(',') : null,
+            artifact: status === 'handoff' ? `${node.loop_id}/handoff.md` : null
+        },
+        blockers
+    };
+    await writeJsonAtomic(loopProofPath(input.root, node.mission_id, node.loop_id), proof);
+    await updateLoopState(input.root, node.mission_id, node.loop_id, {
+        status,
+        current_phase: status === 'completed' ? 'finalizer' : 'handoff',
+        last_gate_result: gate.ok ? 'passed' : 'blocked',
+        blockers,
+        handoff: proof.handoff,
+        budget_used: proof.budget.used
+    });
+    await appendLoopRunLog(input.root, node.mission_id, node.loop_id, { event_type: status === 'completed' ? 'loop_completed' : 'loop_blocked', status });
+    await releaseLoopLease(input.root, node.mission_id, node.loop_id);
+    return proof;
+}
+async function blockedProof(root, node, blockers, started, reason) {
+    const proof = {
+        schema: 'sks.loop-proof.v1',
+        mission_id: node.mission_id,
+        loop_id: node.loop_id,
+        status: 'handoff',
+        iterations: 1,
+        owner_scope: node.owner_scope,
+        worktree: { id: null, path: null, branch: null },
+        maker_result: { ok: false, worker_count: 0, artifacts: [], patch_candidates: [] },
+        checker_result: { ok: false, worker_count: 0, artifacts: [], blockers },
+        gate_result: { ok: false, selected_gates: [], passed_gates: [], failed_gates: [], skipped_gates: [] },
+        budget: {
+            used: { wall_ms: Math.max(1, Date.now() - started), model_calls: 0, subagents: 0, iterations: 1, changed_files: 0, patch_bytes: 0 },
+            max: node.budget
+        },
+        changed_files: [],
+        patch_bytes: 0,
+        handoff: { required: true, reason, artifact: `${node.loop_id}/handoff.md` },
+        blockers
+    };
+    await writeJsonAtomic(loopProofPath(root, node.mission_id, node.loop_id), proof);
+    await updateLoopState(root, node.mission_id, node.loop_id, { status: 'handoff', current_phase: 'handoff', blockers, handoff: proof.handoff });
+    return proof;
+}
+//# sourceMappingURL=loop-runtime.js.map

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

@@ -0,0 +1,60 @@
+import os from 'node:os';
+export function scheduleLoopGraph(nodes, parallelism = 'balanced') {
+    const pending = new Map(nodes.map((node) => [node.loop_id, node]));
+    const completed = new Set();
+    const batches = [];
+    const maxParallel = maxConcurrentLoops(nodes, parallelism);
+    const blockers = [];
+    while (pending.size) {
+        const ready = [...pending.values()].filter((node) => node.dependencies.every((dep) => completed.has(dep)));
+        if (!ready.length) {
+            blockers.push(`loop_dependency_cycle:${[...pending.keys()].join(',')}`);
+            break;
+        }
+        const batch = ready.slice(0, maxParallel);
+        batches.push(batch);
+        for (const node of batch) {
+            pending.delete(node.loop_id);
+            if (node.route !== '$Integration')
+                completed.add(node.loop_id);
+            else
+                completed.add(node.loop_id);
+        }
+    }
+    return { ok: blockers.length === 0, batches, max_active_loops: Math.max(0, ...batches.map((batch) => batch.length)), blockers };
+}
+export function maxConcurrentLoops(nodes, parallelism = 'balanced') {
+    const cores = Math.max(1, os.cpus().length || 1);
+    const base = parallelism === 'safe' ? 2 : parallelism === 'extreme' ? Math.min(16, cores) : Math.min(8, cores);
+    return nodes.some((node) => node.risk.level === 'critical' || node.risk.level === 'high') && parallelism !== 'extreme'
+        ? Math.max(1, Math.min(base, 3))
+        : Math.max(1, base);
+}
+export function graphProofFromLoopProofs(input) {
+    const selected = [...new Set(input.proofs.flatMap((proof) => proof.gate_result.selected_gates))];
+    const passed = [...new Set(input.proofs.flatMap((proof) => proof.gate_result.passed_gates))];
+    const failed = [...new Set(input.proofs.flatMap((proof) => proof.gate_result.failed_gates))];
+    const skipped = [...new Set(input.proofs.flatMap((proof) => proof.gate_result.skipped_gates))];
+    const blockers = [...new Set(input.proofs.flatMap((proof) => proof.blockers))];
+    const sequential = Math.max(input.wallMs, input.proofs.length * Math.max(1, Math.floor(input.wallMs / Math.max(1, input.maxActiveLoops))));
+    return {
+        schema: 'sks.loop-graph-proof.v1',
+        mission_id: input.missionId,
+        ok: blockers.length === 0 && failed.length === 0,
+        total_loops: input.proofs.length,
+        completed_loops: input.proofs.filter((proof) => proof.status === 'completed').length,
+        blocked_loops: input.proofs.filter((proof) => proof.status === 'blocked').length,
+        failed_loops: input.proofs.filter((proof) => proof.status === 'failed').length,
+        handoff_loops: input.proofs.filter((proof) => proof.status === 'handoff').length,
+        parallelism: {
+            max_active_loops: input.maxActiveLoops,
+            max_active_workers: input.maxActiveWorkers,
+            wall_ms: input.wallMs,
+            sequential_estimate_ms: sequential,
+            speedup_ratio: Number((sequential / Math.max(1, input.wallMs)).toFixed(2))
+        },
+        gates: { selected, passed, failed, skipped },
+        blockers
+    };
+}
+//# sourceMappingURL=loop-scheduler.js.map

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.3';
+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/github-release-body-helper.js

@@ -7,6 +7,7 @@ const args = process.argv.slice(2);
 const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
 const truth = readJson('.sneakoscope/release-proof-truth.json') || readJson('dist/release-proof-truth.json');
 const codex0139 = readJson('.sneakoscope/codex-0139-capability.json');
+const codex0139Real = readJson('.sneakoscope/codex-0139-real-probe-summary.json');
 const zellij = readJson('.sneakoscope/reports/zellij-worker-pane-summary.json');
 const changelog = fs.readFileSync(path.join(root, 'CHANGELOG.md'), 'utf8');
 const latest = latestChangelogSection(changelog);
@@ -24,6 +25,7 @@ const body = [
     `Release proof truth: ${truth ? '.sneakoscope/release-proof-truth.json' : 'missing'}`,
     `Codex SDK package: ${sdkVersion || 'unknown'}`,
     `External Codex CLI 0.139 capability: ${codex0139 ? `${codex0139.ok ? 'ok' : 'blocked'}${codex0139.parsed_version ? ` (${codex0139.parsed_version})` : ''}` : 'not recorded'}`,
+    `Codex 0.139 real probes: ${codex0139Real ? `${codex0139Real.ok ? 'ok' : 'blocked'} (${codex0139Real.actual_cli_probe_count || 0} actual CLI, ${codex0139Real.skipped_count || 0} skipped, ${codex0139Real.failed_count || 0} failed)` : 'not run in this release environment. Hermetic fixture gates: passed.'}`,
     `Zellij stacked panes: ${zellij ? `${zellij.stacked_applied_count || 0}/${zellij.stacked_requested_count || 0} applied, fallback ${zellij.stacked_fallback_count || 0}, SLOTS anchors ${zellij.duplicate_slot_anchor_count || 0}` : 'not recorded'}`,
     `Packlist: ${truth?.npm_packlist_count ?? 'unknown'} files / ${truth?.npm_packlist_bytes ?? 'unknown'} bytes`,
     ...(warnings.length ? [`Warnings: ${warnings.join('; ')}`] : ['Warnings: none']),
@@ -34,7 +36,7 @@ const body = [
 if (args.includes('--check')) {
     assertGate(Boolean(truth && truth.schema === 'sks.release-proof-truth.v1'), 'release proof truth missing; run npm run release:proof-truth first');
     assertGate(latest.version === pkg.version, 'latest changelog section must match package version', { latest: latest.version, package: pkg.version });
-    assertGate(body.includes(`Version: ${pkg.version}`) && body.includes('Commit:') && body.includes('Dirty:') && body.includes('Release proof truth:') && body.includes('Codex SDK package:') && body.includes('External Codex CLI 0.139 capability:') && body.includes('Zellij stacked panes:') && body.includes('Packlist:'), 'github release body helper missing source truth fields', { body });
+    assertGate(body.includes(`Version: ${pkg.version}`) && body.includes('Commit:') && body.includes('Dirty:') && body.includes('Release proof truth:') && body.includes('Codex SDK package:') && body.includes('External Codex CLI 0.139 capability:') && body.includes('Codex 0.139 real probes:') && body.includes('Zellij stacked panes:') && body.includes('Packlist:'), 'github release body helper missing source truth fields', { body });
     assertGate(!warnings.some((warning) => warning.includes('package version') || warning.includes('changelog latest') || warning.includes('release proof truth missing')), 'github release body helper source truth warnings must not include version/proof mismatch', { warnings, body });
 }
 console.log(body);