sneakoscope 2.0.11 → 2.0.12

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

@@ -26,7 +26,13 @@ export function buildWorkerPaneArtifact(input) {
     const blockers = input.blockers || [];
     const providerContext = normalizePaneProviderContext(input.providerContext, input.serviceTier);
     const paneTitle = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier, input.backend, input.statusLabel || input.status, input.worktree || null);
-    const directionRequested = input.directionRequested || 'right';
+    const commandText = String(input.workerCommand || '');
+    const isSlotRenderer = commandText.includes('zellij-slot-pane');
+    const paneKind = input.paneKind || (isSlotRenderer ? 'slot_status_renderer' : 'worker_codex_sdk');
+    const scalingPrimitive = input.scalingPrimitive || (isSlotRenderer
+        ? 'native_cli_process_with_zellij_slot_renderer'
+        : 'native_cli_process_in_zellij_worker_pane');
+    const directionRequested = input.directionRequested || 'down';
     const directionApplied = input.directionApplied || 'not_applied';
     return {
         schema: ZELLIJ_WORKER_PANE_SCHEMA,
@@ -41,7 +47,7 @@ export function buildWorkerPaneArtifact(input) {
         session_id: input.sessionId,
         pane_name: paneTitle,
         pane_title: paneTitle,
-        pane_kind: 'worker_codex_sdk',
+        pane_kind: paneKind,
         pane_id: input.paneId || null,
         pane_id_source: paneIdSource,
         provider: providerContext.provider,
@@ -55,8 +61,8 @@ export function buildWorkerPaneArtifact(input) {
         stdout_log: input.stdoutLog,
         stderr_log: input.stderrLog,
         parent_child_transport: 'worker-result-json-and-heartbeat',
-        scaling_primitive: input.scalingPrimitive || 'native_cli_process_in_zellij_worker_pane',
-        command: String(input.workerCommand || '').includes('zellij-slot-pane') ? '<zellij-slot-pane-renderer-command>' : '<native-cli-worker-command>',
+        scaling_primitive: scalingPrimitive,
+        command: isSlotRenderer ? '<zellij-slot-pane-renderer-command>' : '<native-cli-worker-command>',
         create_session: input.createSession || null,
         launch: input.launch || null,
         pane_reconciliation: input.paneReconciliation || null,
@@ -182,7 +188,7 @@ export async function openWorkerPane(input) {
         }
     }
     const focusPaneId = rightColumn?.focusPaneId || slotColumnAnchorPaneId || null;
-    const directionRequested = rightColumn ? 'down' : 'right';
+    const directionRequested = 'down';
     const focus = focusPaneId
         ? await focusZellijPaneById(input.sessionName, focusPaneId, cwd)
         : null;
@@ -282,7 +288,7 @@ export async function openWorkerPane(input) {
         session_name: input.sessionName,
         pane_name: paneName,
         pane_title: paneName,
-        pane_kind: 'worker_codex_sdk',
+        pane_kind: record.pane_kind,
         pane_id: record.pane_id,
         pane_id_source: record.pane_id_source,
         provider: record.provider,
@@ -302,7 +308,7 @@ export async function openWorkerPane(input) {
         patch_envelope_path: input.patchEnvelopePath,
         parent_child_transport: 'worker-result-json-and-heartbeat',
         persistent_slot_lane: false,
-        scaling_primitive: 'native_cli_process_in_zellij_worker_pane',
+        scaling_primitive: record.scaling_primitive,
         blockers
     });
     return record;

package/dist/scripts/agent-real-codex-in-zellij-worker-pane-check.js

@@ -123,7 +123,7 @@ async function runRealGate({ sourceOk, eventProof }) {
 async function inspectRealLedger(ledgerRoot) {
     const swarm = await readJson(path.join(ledgerRoot, 'agent-native-cli-session-swarm.json'), null);
     const records = Array.isArray(swarm?.records) ? swarm.records : [];
-    const workerRecords = records.filter((row) => row.scaling_primitive === 'native_cli_process_in_zellij_worker_pane');
+    const workerRecords = records.filter(isZellijCodexWorkerRecord);
     const eventsByWorker = [];
     for (const record of workerRecords) {
         const workerDir = String(record.worker_artifact_dir || '');
@@ -137,7 +137,7 @@ async function inspectRealLedger(ledgerRoot) {
     const blockers = [
         ...(swarm?.ok === true ? [] : ['real_codex_zellij_swarm_not_ok']),
         ...(workerRecords.length >= 1 ? [] : ['real_codex_zellij_worker_record_missing']),
-        ...(workerRecords.some((row) => row.pane_kind === 'worker_codex_sdk') ? [] : ['real_codex_zellij_worker_pane_kind_missing']),
+        ...(workerRecords.some((row) => row.pane_kind === 'worker_codex_sdk' || row.pane_kind === 'slot_status_renderer') ? [] : ['real_codex_zellij_worker_pane_kind_missing']),
         ...(workerRecords.every((row) => manager.isRealZellijWorkerPaneIdSource(row.zellij_pane_id_source)) ? [] : ['real_codex_zellij_pane_id_source_not_real']),
         ...(workerRecords.every((row) => row.zellij_pane_id) ? [] : ['real_codex_zellij_pane_id_missing']),
         ...(workerRecords.every((row) => row.sdk_thread_id) ? [] : ['real_codex_zellij_sdk_thread_missing']),
@@ -171,6 +171,12 @@ async function inspectRealLedger(ledgerRoot) {
         blockers
     };
 }
+function isZellijCodexWorkerRecord(row) {
+    return row?.scaling_primitive === 'native_cli_process_in_zellij_worker_pane'
+        || row?.scaling_primitive === 'native_cli_process_with_zellij_slot_renderer'
+        || row?.pane_kind === 'worker_codex_sdk'
+        || row?.pane_kind === 'slot_status_renderer';
+}
 async function emit(report) {
     await fs.mkdir(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
     await fs.writeFile(path.join(root, '.sneakoscope', 'reports', 'agent-real-codex-in-zellij-worker-pane.json'), `${JSON.stringify(report, null, 2)}\n`);

package/dist/scripts/agent-slot-pane-binding-proof-check.js

@@ -14,10 +14,10 @@ const records = [1, 2, 3].map((index) => ({
     session_id: `slot-001-gen-${index}`,
     slot_id: 'slot-001',
     generation_index: index,
-    pane_kind: 'worker_codex_sdk',
+    pane_kind: index === 1 ? 'slot_status_renderer' : 'worker_codex_sdk',
     zellij_pane_id: String(100 + index),
     zellij_pane_id_source: index % 2 ? 'zellij_worker_new_pane_stdout' : 'zellij_worker_list_panes',
-    scaling_primitive: 'native_cli_process_in_zellij_worker_pane',
+    scaling_primitive: index === 1 ? 'native_cli_process_with_zellij_slot_renderer' : 'native_cli_process_in_zellij_worker_pane',
     sdk_thread_id: `sdk-thread-${index}`,
     sdk_run_id: `sdk-run-${index}`,
     stream_event_count: 4,
@@ -35,9 +35,9 @@ await fs.writeFile(path.join(tmp, 'agent-native-cli-session-swarm.json'), `${JSO
 }, null, 2)}\n`);
 await fs.writeFile(path.join(tmp, 'agent-zellij-pane-launch-ledger.jsonl'), records.map((record) => JSON.stringify({
     schema: 'sks.agent-zellij-pane-launch.v1',
-    pane_kind: 'worker_codex_sdk',
+    pane_kind: record.pane_kind,
     persistent_slot_lane: false,
-    scaling_primitive: 'native_cli_process_in_zellij_worker_pane',
+    scaling_primitive: record.scaling_primitive,
     slot_id: record.slot_id,
     generation_index: record.generation_index,
     pane_id: record.zellij_pane_id,

package/dist/scripts/codex-sdk-release-review-pipeline-check.js

@@ -3,10 +3,11 @@
 import { assertGate, emitGate, packageScripts, readText, releaseGateIds } from './lib/codex-sdk-gate-lib.js';
 const scripts = packageScripts();
 const releaseRealCheck = String(scripts['release:real-check'] || '');
+const releaseRealCheckSource = readText('src/scripts/release-real-check.ts');
 const releaseGates = releaseGateIds();
 assertGate(releaseGates.has('codex-sdk:capability'), 'release gate DAG must include Codex SDK capability gate');
 assertGate(releaseGates.has('codex-sdk:all-pipelines'), 'release gate DAG must include Codex SDK all-pipelines gate');
-assertGate(releaseRealCheck.includes('codex-sdk:real-smoke'), 'release:real-check must include Codex SDK real smoke');
+assertGate(releaseRealCheck.includes('codex-sdk:real-smoke') || releaseRealCheckSource.includes('codex-sdk:real-smoke'), 'release:real-check must include Codex SDK real smoke');
 assertGate(readText('src/core/agents/agent-orchestrator.ts').includes('legacy_codex_exec_runtime_removed'), 'orchestrator must block legacy codex-exec requests');
 emitGate('codex-sdk:release-review-pipeline', { release_gate_dag_contains_sdk: true });
 //# sourceMappingURL=codex-sdk-release-review-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/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));