sneakoscope 2.0.11 → 2.0.13

package/dist/scripts/codex-sdk-research-pipeline-check.js

@@ -4,5 +4,12 @@ import { assertGate, emitGate, readText } from './lib/codex-sdk-gate-lib.js';
 const source = readText('src/core/commands/research-command.ts');
 assertGate(source.includes("backend: mock ? 'fake' : 'codex-sdk'"), 'Research pipeline must default native agents to codex-sdk');
 assertGate(source.includes("flag(args, '--autoresearch') ? '$AutoResearch' : '$Research'"), 'Research/AutoResearch route selection missing');
+assertGate(source.includes('narutoWorkGraph: researchWorkGraph'), 'Research pipeline must pass the stage-aware Naruto work graph');
+assertGate(source.includes('readonly: true'), 'Research pipeline must force read-only native orchestration');
+assertGate(source.includes('quality_metrics'), 'Research pipeline JSON output must include quality metrics');
+const researchCore = readText('src/core/research.ts');
+assertGate(researchCore.includes('readResearchQualityContract'), 'Research gate must read research-quality-contract.json');
+assertGate(researchCore.includes('claim_evidence_matrix_missing'), 'Research gate must require claim-evidence-matrix.json');
+assertGate(researchCore.includes('research_final_review_not_approved'), 'Research gate must require final reviewer approval');
 emitGate('codex-sdk:research-pipeline', { route: '$Research' });
 //# sourceMappingURL=codex-sdk-research-pipeline-check.js.map

package/dist/scripts/codex-sdk-zellij-pane-binding-check.js

@@ -7,7 +7,7 @@ const proofSource = readText('src/core/agents/agent-slot-pane-binding-proof.ts')
 const managerSource = readText('src/core/zellij/zellij-worker-pane-manager.ts');
 assertGate(fixture.proof.zellij_pane_id === 'pane-999', 'control proof must link zellij pane id', fixture.proof);
 assertGate(swarmSource.includes('codex_sdk_thread_started'), 'swarm must emit SDK thread event');
-assertGate(proofSource.includes('worker_codex_sdk'), 'slot-pane proof must require worker_codex_sdk pane kind');
-assertGate(managerSource.includes("pane_kind: 'worker_codex_sdk'"), 'worker pane manager must record worker_codex_sdk pane kind');
+assertGate(proofSource.includes('worker_codex_sdk') && proofSource.includes('slot_status_renderer'), 'slot-pane proof must accept worker command panes and compact slot renderer panes');
+assertGate(managerSource.includes('slot_status_renderer') && managerSource.includes('worker_codex_sdk'), 'worker pane manager must distinguish slot renderer and worker command pane kinds');
 emitGate('codex-sdk:zellij-pane-binding', { zellij_pane_id: fixture.proof.zellij_pane_id, sdk_thread_id: fixture.proof.sdk_thread_id });
 //# sourceMappingURL=codex-sdk-zellij-pane-binding-check.js.map

package/dist/scripts/git-worktree-cross-rebase-check.js

@@ -13,15 +13,27 @@ fs.writeFileSync(path.join(root, 'base.txt'), 'base\n');
 await runGitCommand(root, ['add', 'base.txt']);
 await runGitCommand(root, ['commit', '-m', 'base']);
 const workerPath = path.join(root, '..', `worker-${process.pid}`);
+const dirtyWorkerPath = path.join(root, '..', `worker-dirty-${process.pid}`);
+const runningWorkerPath = path.join(root, '..', `worker-running-${process.pid}`);
 await runGitCommand(root, ['worktree', 'add', workerPath, 'HEAD']);
+await runGitCommand(root, ['worktree', 'add', dirtyWorkerPath, 'HEAD']);
+await runGitCommand(root, ['worktree', 'add', runningWorkerPath, 'HEAD']);
+fs.writeFileSync(path.join(dirtyWorkerPath, 'dirty.txt'), 'dirty\n');
 fs.writeFileSync(path.join(root, 'integration.txt'), 'integration\n');
 await runGitCommand(root, ['add', 'integration.txt']);
 await runGitCommand(root, ['commit', '-m', 'integration']);
 const head = gitOutputLine(await runGitCommand(root, ['rev-parse', 'HEAD']));
 const report = await crossRebaseIdleWorktrees({
     integrationHead: head,
-    workers: [{ worker_id: 'W1', worktree_path: workerPath, state: 'idle' }]
+    workers: [
+        { worker_id: 'W1', worktree_path: workerPath, state: 'idle' },
+        { worker_id: 'W-dirty', worktree_path: dirtyWorkerPath, state: 'idle' },
+        { worker_id: 'W-running', worktree_path: runningWorkerPath, state: 'running' }
+    ]
 });
 assertGate(report.ok && report.applied_count === 1, 'Idle worktrees must cross-rebase to the integration head', report);
+assertGate(report.skipped_count === 2, 'Dirty and running worktrees must be skipped during cross-rebase', report);
+assertGate(report.records.some((row) => row.worker_id === 'W-dirty' && row.status === 'skipped' && row.reason === 'dirty_worktree_skipped'), 'Dirty worktree must skip cross-rebase', report);
+assertGate(report.records.some((row) => row.worker_id === 'W-running' && row.status === 'skipped' && row.reason === 'worker_not_idle'), 'Running worktree must skip cross-rebase', report);
 emitGate('git:worktree-cross-rebase', report);
 //# sourceMappingURL=git-worktree-cross-rebase-check.js.map

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

@@ -20,6 +20,7 @@ const diffB = await diffMod.exportGitWorktreeDiff({ mainRepoRoot: repo, worktree
 const integration = await integrationMod.createGitIntegrationWorktree({ repoRoot: repo, missionId: 'M-merge' });
 const report = await queueMod.applyGitWorktreeMergeQueue({ integrationWorktreePath: integration.worktree_path, diffs: [diffA, diffB] });
 assertGate(report.ok === true && report.applied_count === 2, 'merge queue must apply non-conflicting worktree diffs', report);
+assertGate((report.strategy_results || []).every((row) => row.strategy === 'diff-apply-3way'), 'merge queue must record the diff apply strategy for worktree diffs', report.strategy_results || []);
 assertGate(fs.readFileSync(path.join(integration.worktree_path, 'a.txt'), 'utf8').includes('from-a'), 'integration worktree must include first diff');
 assertGate(fs.readFileSync(path.join(integration.worktree_path, 'b.txt'), 'utf8').includes('from-b'), 'integration worktree must include second diff');
 assertGate(fs.readFileSync(path.join(repo, 'a.txt'), 'utf8') === 'alpha\n', 'main worktree must remain unchanged before integration commit');

package/dist/scripts/local-collab-worktree-gpt-final-apply-policy-check.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+import { gptFinalRequiredForPipeline } from '../core/pipeline/gpt-final-required.js';
+import { finalizePipelineResult } from '../core/pipeline/finalize-pipeline-result.js';
+import { selectFinalGptPatchSource } from '../core/pipeline/final-gpt-patch-stage.js';
+const worktreeEnvelope = {
+    schema: 'sks.agent-patch-envelope.v1',
+    source: 'git-worktree-diff',
+    git_worktree: {
+        worktree_path: '/tmp/sks-worker',
+        changed_files: ['src/core/example.ts']
+    },
+    operations: [{ op: 'git_apply_patch', path: '.', diff: 'diff --git a/src/core/example.ts b/src/core/example.ts\n' }]
+};
+const requirement = gptFinalRequiredForPipeline({
+    localParticipated: false,
+    candidateResults: [{ backend: 'codex-sdk', patch_envelopes: [worktreeEnvelope] }],
+    candidatePatchEnvelopes: [worktreeEnvelope]
+});
+const blocked = await finalizePipelineResult({
+    route: '$Naruto',
+    missionId: 'M-worktree-gpt-final-policy',
+    localParticipated: false,
+    candidateResults: [{ backend: 'codex-sdk', patch_envelopes: [worktreeEnvelope] }],
+    candidatePatchEnvelopes: [worktreeEnvelope],
+    verificationResults: [],
+    sideEffectReport: {},
+    mutationLedger: {},
+    rollbackPlan: {},
+    applyPatches: true,
+    forceGptFinalUnavailable: true
+});
+const modified = selectFinalGptPatchSource({
+    result: {
+        status: 'modified',
+        modified_patch_envelopes: [{ ...worktreeEnvelope, source: 'model_authored', operations: [{ op: 'replace', path: 'src/core/example.ts', search: 'old', replace: 'new' }] }]
+    }
+}, [worktreeEnvelope]);
+const rejected = selectFinalGptPatchSource({ result: { status: 'rejected' } }, [worktreeEnvelope]);
+const ok = requirement.gpt_final_required === true
+    && requirement.worktree_participated === true
+    && blocked.ok === false
+    && blocked.apply_allowed === false
+    && blocked.blockers.includes('gpt_final_arbiter_required_not_passed')
+    && modified.ok === true
+    && modified.final_patch_source === 'gpt_final_arbiter'
+    && modified.patch_envelopes[0]?.source === 'model_authored'
+    && rejected.ok === false
+    && rejected.final_patch_source === 'blocked';
+assertGate(ok, 'Worktree/local candidate output must require GPT Final before apply, and GPT modified/rejected decisions must control final patch source', {
+    requirement,
+    blocked,
+    modified,
+    rejected
+});
+emitGate('local-collab:worktree-gpt-final-apply-policy', {
+    requirement,
+    blocked_apply_allowed: blocked.apply_allowed,
+    modified_source: modified.final_patch_source,
+    rejected_source: rejected.final_patch_source
+});
+//# sourceMappingURL=local-collab-worktree-gpt-final-apply-policy-check.js.map

package/dist/scripts/naruto-actual-worker-control-plane-check.js

@@ -6,6 +6,7 @@ import path from 'node:path';
 import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
 import { buildNarutoWorkGraph } from '../core/naruto/naruto-work-graph.js';
 import { collectActualNarutoWorker, spawnActualNarutoWorker } from '../core/naruto/naruto-real-worker-runtime.js';
+import { narutoCommand } from '../core/commands/naruto-command.js';
 process.env.SKS_CODEX_SDK_FAKE = '1';
 const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-naruto-actual-worker-'));
 const graph = buildNarutoWorkGraph({ requestedClones: 1, totalWorkItems: 1, readonly: true, writeCapable: false });
@@ -20,10 +21,36 @@ const handle = await spawnActualNarutoWorker({
 });
 const collected = await collectActualNarutoWorker(handle);
 const result = JSON.parse(fs.readFileSync(path.join(handle.worker_artifact_dir, 'worker-result.json'), 'utf8'));
+const fullRoute = await narutoCommand([
+    'run',
+    'Naruto actual worker full command control plane check',
+    '--json',
+    '--backend',
+    'fake',
+    '--backend-explicit',
+    '--clones',
+    '2',
+    '--work-items',
+    '2',
+    '--readonly',
+    '--no-open-zellij',
+    '--smoke'
+]);
+const missionRoot = path.join(process.cwd(), '.sneakoscope', 'missions', fullRoute.mission_id || '', 'agents', 'naruto-real-workers');
+const fullWorkerResults = fs.existsSync(missionRoot)
+    ? fs.readdirSync(missionRoot).map((name) => {
+        const file = path.join(missionRoot, name, 'worker-result.json');
+        return fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf8')) : null;
+    }).filter(Boolean)
+    : [];
 const ok = collected.ok === true
     && result.ok === true
     && result.control_plane_result?.worker_result_path
-    && result.control_plane_result?.structured_output_valid === true;
-assertGate(ok, 'Naruto actual worker must call Codex Control Plane and write structured result evidence', { collected, result });
-emitGate('naruto:actual-worker-control-plane', { collected, result });
+    && result.control_plane_result?.structured_output_valid === true
+    && fullRoute.active_pool?.real_runtime?.runtime_source_of_truth === 'pre_run_smoke_only'
+    && fullRoute.runtime_source_of_truth === 'agent-orchestrator-scheduler'
+    && fullWorkerResults.length >= 1
+    && fullWorkerResults.every((row) => row.control_plane_result?.structured_output_valid === true);
+assertGate(ok, 'Naruto actual worker must call Codex Control Plane directly and through the explicit full-route smoke path', { collected, result, fullRoute, fullWorkerResults });
+emitGate('naruto:actual-worker-control-plane', { collected, result, full_route_mission_id: fullRoute.mission_id, full_worker_result_count: fullWorkerResults.length });
 //# sourceMappingURL=naruto-actual-worker-control-plane-check.js.map

package/dist/scripts/naruto-allocation-runtime-wiring-check.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+import { runNativeAgentOrchestrator } from '../core/agents/agent-orchestrator.js';
+import { buildNarutoCloneRoster } from '../core/agents/agent-roster.js';
+import { buildNarutoWorkGraph } from '../core/naruto/naruto-work-graph.js';
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-naruto-runtime-wiring-'));
+const roster = buildNarutoCloneRoster({ clones: 3, readonly: true, prompt: 'runtime wiring check' });
+const graph = buildNarutoWorkGraph({
+    requestedClones: 3,
+    totalWorkItems: 3,
+    readonly: true,
+    writeCapable: false,
+    allocationAssignments: [
+        assignment('NW-000001', 'naruto_clone_001', 42),
+        assignment('NW-000002', 'naruto_clone_002', 41),
+        assignment('NW-000003', 'naruto_clone_999', 1)
+    ]
+});
+const result = await runNativeAgentOrchestrator({
+    root,
+    route: '$Naruto',
+    routeCommand: 'sks naruto run',
+    routeBlackboxKind: 'allocation_runtime_wiring_gate',
+    prompt: 'Naruto allocation runtime wiring check',
+    roster,
+    agents: 3,
+    concurrency: 2,
+    targetActiveSlots: 2,
+    desiredWorkItemCount: 3,
+    minimumWorkItems: 3,
+    backend: 'fake',
+    backendExplicit: true,
+    mock: true,
+    readonly: true,
+    nativeCliSwarm: false,
+    narutoMode: true,
+    narutoWorkGraph: graph,
+    narutoAllocationPolicy: { schema: 'sks.naruto-allocation-policy.v1', ok: true, assignments: graph.work_items.map((item) => ({ task_id: item.id, owner: item.owner })) },
+    narutoRebalancePolicy: { schema: 'sks.naruto-rebalance-policy.v1', ok: true, decisions: [] }
+});
+const ledgerRoot = path.join(root, result.ledger_root || '.');
+const wiring = JSON.parse(fs.readFileSync(path.join(ledgerRoot, 'naruto-runtime-wiring.json'), 'utf8'));
+const queue = JSON.parse(fs.readFileSync(path.join(ledgerRoot, 'agent-work-queue.json'), 'utf8'));
+const owners = queue.items.map((item) => item.slice?.owner_agent_id);
+const runtimeProofs = (result.results || []).map((row) => row.naruto_runtime).filter(Boolean);
+const schedulerOk = result.scheduler?.state?.completed_count === 3
+    && result.scheduler?.state?.failed_count === 0
+    && result.scheduler?.state?.blocked_count === 0
+    && result.scheduler?.state?.pending_queue_drained === true
+    && Array.isArray(result.scheduler?.state?.blockers)
+    && result.scheduler.state.blockers.length === 0;
+const ok = schedulerOk
+    && wiring.ok === true
+    && wiring.scheduler_slice_count === 3
+    && owners.includes('naruto_clone_001')
+    && owners.includes('naruto_clone_002')
+    && wiring.slice_owners.some((row) => row.original_owner === 'naruto_clone_999' && row.rebalanced === true)
+    && runtimeProofs.length === 3
+    && runtimeProofs.every((row) => row.source_of_truth === 'agent-orchestrator-scheduler');
+assertGate(ok, 'Naruto allocation must be wired into scheduler slices, queue ownership, and worker runtime proof', {
+    result_ok: result.ok,
+    result_proof_blockers: result.proof?.blockers || [],
+    scheduler: result.scheduler?.state || null,
+    wiring,
+    owners,
+    runtimeProofs
+});
+emitGate('naruto:allocation-runtime-wiring', {
+    wiring,
+    owners,
+    scheduler_ok: schedulerOk,
+    runtime_proof_count: runtimeProofs.length
+});
+function assignment(taskId, owner, score) {
+    return {
+        task_id: taskId,
+        owner,
+        allocation_reason: `fixture owner ${owner}`,
+        allocation_score: score,
+        hints: {
+            role: 'verifier',
+            paths: ['src/core/naruto/runtime.ts'],
+            domains: ['src/core/naruto'],
+            writePaths: []
+        }
+    };
+}
+//# sourceMappingURL=naruto-allocation-runtime-wiring-check.js.map

package/dist/scripts/naruto-orchestrator-runtime-source-check.js

@@ -2,10 +2,69 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
-const source = fs.readFileSync(path.join(process.cwd(), 'src/core/commands/naruto-command.ts'), 'utf8');
-const ok = source.includes("runtime_source_of_truth: 'agent-orchestrator-scheduler'")
-    && source.includes("production_runtime_source_of_truth: 'agent-orchestrator-scheduler'")
-    && source.includes('pre_run_smoke_never_owns_production_runtime');
-assertGate(ok, 'Naruto production runtime source of truth must be the native agent orchestrator scheduler, not pre-run active-pool smoke', { ok });
-emitGate('naruto:orchestrator-runtime-source', { ok });
+import { narutoCommand } from '../core/commands/naruto-command.js';
+const summary = await narutoCommand([
+    'run',
+    'Naruto orchestrator runtime source artifact check',
+    '--json',
+    '--backend',
+    'fake',
+    '--clones',
+    '2',
+    '--work-items',
+    '2',
+    '--readonly',
+    '--no-open-zellij'
+]);
+const ledgerRoot = path.join(process.cwd(), '.sneakoscope', 'missions', summary.mission_id || '', 'agents');
+const realPool = readJson(path.join(ledgerRoot, 'naruto-real-active-pool.json'));
+const wiring = readJson(path.join(ledgerRoot, 'naruto-runtime-wiring.json'));
+const artifactText = collectText(ledgerRoot);
+const ok = summary.runtime_source_of_truth === 'agent-orchestrator-scheduler'
+    && summary.pre_run_real_active_pool_source === 'skipped'
+    && realPool?.status === 'skipped'
+    && realPool?.runtime_source_of_truth === 'agent-orchestrator-scheduler'
+    && realPool?.reason === 'pre_run_smoke_disabled_for_production'
+    && wiring?.source_of_truth === 'naruto-work-graph'
+    && artifactText.includes('agent-orchestrator-scheduler')
+    && artifactText.includes('pre_run_smoke_never_owns_production_runtime');
+assertGate(ok, 'Naruto production runtime source of truth must be proven by command artifacts, not source-string checks', {
+    summary,
+    realPool,
+    wiring
+});
+emitGate('naruto:orchestrator-runtime-source', {
+    mission_id: summary.mission_id,
+    runtime_source_of_truth: summary.runtime_source_of_truth,
+    pre_run_real_active_pool_source: summary.pre_run_real_active_pool_source,
+    real_pool_status: realPool?.status || null,
+    wiring_ok: wiring?.ok === true
+});
+function readJson(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function collectText(root) {
+    const chunks = [];
+    const stack = [root];
+    while (stack.length) {
+        const current = stack.pop();
+        if (!current || !fs.existsSync(current))
+            continue;
+        const stat = fs.statSync(current);
+        if (stat.isDirectory()) {
+            for (const child of fs.readdirSync(current))
+                stack.push(path.join(current, child));
+            continue;
+        }
+        if (!/\.(json|jsonl)$/.test(current))
+            continue;
+        chunks.push(fs.readFileSync(current, 'utf8'));
+    }
+    return chunks.join('\n');
+}
 //# sourceMappingURL=naruto-orchestrator-runtime-source-check.js.map

package/dist/scripts/naruto-rebalance-policy-check.js

@@ -23,6 +23,19 @@ const decisions = rebalanceNarutoReadyWork({
     workers: [{ id: 'idle-1', role: 'verifier', lane: 'src/core', alive: true, state: 'idle' }],
     completedTaskIds: []
 });
-assertGate(decisions.length === 1 && decisions[0]?.task_id === 'A', 'Naruto rebalance must assign only dependency-ready pending work to idle workers', { decisions });
-emitGate('naruto:rebalance-policy', { decisions });
+const inactiveOwner = rebalanceNarutoReadyWork({
+    tasks: [{ ...item('C'), owner: 'missing-worker' }],
+    workers: [{ id: 'idle-2', role: 'verifier', lane: 'src/core', alive: true, state: 'idle' }],
+    completedTaskIds: []
+});
+const writeConflict = rebalanceNarutoReadyWork({
+    tasks: [{ ...item('D'), write_paths: ['src/core/naruto/runtime.ts'], write_allowed: true }],
+    workers: [{ id: 'idle-3', role: 'verifier', lane: 'src/core', alive: true, state: 'idle' }],
+    completedTaskIds: [],
+    activeWritePaths: ['src/core/naruto/runtime.ts']
+});
+assertGate(decisions.length === 1 && decisions[0]?.task_id === 'A'
+    && inactiveOwner.length === 1 && inactiveOwner[0]?.worker_id === 'idle-2'
+    && writeConflict.length === 0, 'Naruto rebalance must assign dependency-ready work, reassign inactive owners, and skip active write conflicts', { decisions, inactiveOwner, writeConflict });
+emitGate('naruto:rebalance-policy', { decisions, inactiveOwner, writeConflict });
 //# sourceMappingURL=naruto-rebalance-policy-check.js.map

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

@@ -114,7 +114,7 @@ const writePaths = commandGraph.work_items.filter((row) => row.write_allowed).fl
 assertGate(new Set(writePaths).size > 1, 'naruto command default patch-envelope leases must be per work item, not one shared write path', { sample: writePaths.slice(0, 8), unique: new Set(writePaths).size });
 assertGate(commandGraph.active_waves.some((wave) => wave.write_paths.length > 1), 'naruto command graph must contain a parallel write wave when route-local patch envelopes do not overlap', { waves: commandGraph.active_waves.slice(0, 3) });
 const state = parsed.run?.scheduler?.state || parsed.run?.scheduler || {};
-assertGate(Number(state.completed_count) === proofClones, 'all clone work items must complete despite throttling', { completed_count: state.completed_count });
+assertGate(Number(state.completed_count) === Number(parsed.work_graph?.total_work_items || 0) && Number(state.completed_count) >= proofClones, 'all clone work items must complete despite throttling', { completed_count: state.completed_count, total_work_items: parsed.work_graph?.total_work_items, proofClones });
 const explicitConcurrency = spawnSync(process.execPath, [cli, 'naruto', 'run', 'explicit concurrency', '--clones', '6', '--backend', 'fake', '--work-items', '6', '--concurrency', '6', '--json'], { cwd: root, env: childEnv, encoding: 'utf8', timeout: 120000, maxBuffer: 4 * 1024 * 1024 });
 const explicitParsed = parseJson(explicitConcurrency.stdout);
 assertGate(explicitConcurrency.status === 0 && explicitParsed?.target_active_slots === 6, 'explicit --concurrency must let Naruto use the requested parallel slot count', { status: explicitConcurrency.status, target_active_slots: explicitParsed?.target_active_slots });

package/dist/scripts/packlist-performance-check.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
-const MAX_FILES = Number(process.env.SKS_MAX_PACK_FILES || 1200);
+const MAX_FILES = Number(process.env.SKS_MAX_PACK_FILES || 1250);
 const MAX_UNPACKED = Number(process.env.SKS_MAX_UNPACKED_BYTES || 6 * 1024 * 1024);
 const MAX_PACKED = Number(process.env.SKS_MAX_PACK_BYTES || 1536 * 1024);
 function runNpmPack() {

package/dist/scripts/release-dag-full-coverage-check.js

@@ -19,12 +19,16 @@ const gateIds = new Set(manifest.gates.map((gate) => gate.id));
 const releasePresetIds = new Set(manifest.gates.filter((gate) => Array.isArray(gate.preset) && gate.preset.includes('release')).map((gate) => gate.id));
 const requiredReleasePresetIds = [
     'zellij:first-slot-down-stack',
+    'zellij:slot-renderer-proof-semantics',
     'naruto:allocation-policy',
     'naruto:rebalance-policy',
+    'naruto:allocation-runtime-wiring',
     'naruto:actual-worker-control-plane',
     'naruto:orchestrator-runtime-source',
     'git:worktree-checkpoint',
     'git:worktree-cross-rebase',
+    'local-collab:worktree-gpt-final-apply-policy',
+    'release:cache-glob-hashing',
     'release:dag-full-coverage'
 ];
 const missing = legacyIds.filter((id) => !gateIds.has(id) && !allowlist.has(id));