sneakoscope 2.0.12 → 2.0.14

package/dist/core/version.js

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

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

@@ -8,14 +8,16 @@ export function renderZellijSlotColumnAnchor(input = {}) {
     const header = `SLOTS active ${active}/${visible} · headless ${headless} · q ${queue}`;
     const workers = Array.isArray(input.workerRows) ? input.workerRows : [];
     if (!workers.length)
-        return header;
+        return `${header}\nvisible slot panes stack below this anchor`;
     const maxRows = Math.max(1, nonNegativeInt(input.maxWorkerRows, input.mode === 'full-debug' ? 24 : 12));
-    const visibleRows = workers.slice(0, maxRows);
+    const overflowRows = workers.filter((row) => row.placement === 'headless').slice(0, maxRows);
+    const visibleRows = overflowRows.length ? overflowRows : workers.filter((row) => row.placement !== 'zellij-pane').slice(0, maxRows);
     const hidden = Math.max(0, workers.length - visibleRows.length);
     return [
         header,
+        `visible slot panes stack below this anchor`,
         ...visibleRows.map((row, index) => renderWorkerRow(row, index + 1)),
-        ...(hidden ? [`+${hidden} more worker${hidden === 1 ? '' : 's'}`] : [])
+        ...(hidden && visibleRows.length ? [`+${hidden} worker${hidden === 1 ? '' : 's'} in dedicated panes or overflow`] : [])
     ].join('\n');
 }
 export async function renderZellijSlotColumnAnchorFromArtifacts(input) {

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

@@ -2,40 +2,121 @@ import fs from 'node:fs';
 import path from 'node:path';
 export function renderZellijSlotPane(input) {
     const mode = input.mode || 'compact-slots';
-    const maxLines = mode === 'compact-slots' ? 5 : mode === 'dashboard-plus-slots' ? 8 : 20;
-    const task = trimInline(input.currentFile || input.currentTask || '-', 56);
+    const maxLines = mode === 'compact-slots' ? 17 : mode === 'dashboard-plus-slots' ? 20 : 32;
+    const task = trimInline(input.currentTask || input.currentFile || 'waiting for worker intake', 78);
     const heartbeat = input.heartbeatAgeMs == null
         ? 'unknown'
         : input.heartbeatAgeMs < 1000
             ? 'now'
             : `${Math.max(1, Math.round(input.heartbeatAgeMs / 1000))}s ago`;
+    const files = firstNonEmptyList(input.changedFiles, input.patchFiles, input.plannedFiles, input.currentFile ? [input.currentFile] : []);
+    const events = (input.eventLines || []).filter(Boolean).slice(-3);
+    const stdout = (input.stdoutTail || []).filter(Boolean).slice(-2);
+    const stderr = (input.stderrTail || []).filter(Boolean).slice(-1);
     const rows = [
-        `${input.slotId} gen-${Math.max(1, Math.floor(Number(input.generationIndex) || 1))}`,
-        `${trimInline(input.role || 'worker', 18)} - ${trimInline(input.backend || 'codex-sdk', 18)} - ${trimInline(input.worktreeId || '-', 18)}`,
-        `status: ${trimInline(input.status || 'running', 14)} ${task}`,
-        `patch: ${trimInline(input.patchStatus || 'queued', 18)}  verify: ${trimInline(input.verifyStatus || 'queued', 18)}`,
-        `heartbeat: ${heartbeat}`
-    ];
-    return rows.slice(0, maxLines).join('\n');
+        `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)}`,
+        `model: ${trimInline(input.model || 'unknown', 28)}  reasoning: ${trimInline(input.reasoningEffort || 'unknown', 16)}${input.authMode ? `  auth: ${trimInline(input.authMode, 14)}` : ''}`,
+        input.sessionId ? `session: ${trimInline(input.sessionId, 62)}` : null,
+        `heartbeat: ${heartbeat}${input.heartbeatEvent ? `  event: ${trimInline(input.heartbeatEvent, 40)}` : ''}`,
+        `doing: ${task}`,
+        `files: ${trimInline(files.length ? files.join(', ') : 'no changed file yet', 78)}`,
+        `patch: ${trimInline(input.patchStatus || 'queued', 24)}  verify: ${trimInline(input.verifyStatus || 'queued', 24)}`,
+        ...events.map((event) => `event: ${trimInline(event, 78)}`),
+        ...stdout.map((line) => `out: ${trimInline(line, 79)}`),
+        ...stderr.map((line) => `err: ${trimInline(line, 79)}`)
+    ].filter((row) => Boolean(row));
+    return frameSlotPane(`LIVE SLOT ${input.slotId}`, rows.slice(0, Math.max(1, maxLines - 2)));
 }
 export async function renderZellijSlotPaneFromArtifacts(input) {
     const artifactDir = path.resolve(input.artifactDir);
     const result = await readJson(path.join(artifactDir, 'worker-result.json'));
+    const intake = await readJson(path.join(artifactDir, 'worker-intake.json'));
+    const backendReport = await readJson(path.join(artifactDir, 'worker-backend-router-report.json'));
+    const fastReport = await readJson(path.join(artifactDir, 'worker-fast-mode.json'));
+    const paneReport = await readJson(path.join(artifactDir, 'zellij-worker-pane.json'));
+    const codexProof = await readJson(path.join(artifactDir, 'codex-control-proof.json'));
+    const localProof = await readJson(path.join(artifactDir, 'local-llm-proof.json'));
+    const patch = await firstJson([
+        path.join(artifactDir, 'worker-patch-envelope.json'),
+        path.join(artifactDir, 'codex-sdk-patch-envelope.json'),
+        path.join(artifactDir, 'python-codex-sdk-patch-envelope.json'),
+        path.join(artifactDir, 'local-llm-patch-envelope.json')
+    ]);
     const heartbeatPath = path.join(artifactDir, 'worker-heartbeat.jsonl');
     const heartbeatMtime = await statMtimeMs(heartbeatPath);
+    const heartbeatRows = await readJsonlTail(heartbeatPath, 2);
+    const eventRows = await readJsonlTails([
+        path.join(artifactDir, 'codex-sdk-events.jsonl'),
+        path.join(artifactDir, 'python-codex-sdk-events.jsonl'),
+        path.join(artifactDir, 'local-llm-events.jsonl'),
+        path.join(artifactDir, 'zellij-worker-pane-events.jsonl')
+    ], 6);
+    const patchFiles = patchPaths(patch || result);
+    const changedFiles = normalizeList(result?.changed_files);
+    const plannedFiles = normalizeList([
+        ...(Array.isArray(intake?.slice?.write_paths) ? intake.slice.write_paths : []),
+        ...(Array.isArray(intake?.slice?.readonly_paths) ? intake.slice.readonly_paths : []),
+        ...(Array.isArray(intake?.input_files) ? intake.input_files : [])
+    ]);
     const now = Date.now();
     return renderZellijSlotPane({
         slotId: input.slotId,
         generationIndex: input.generationIndex,
-        role: input.role || result?.persona_id || result?.agent_id || null,
-        backend: input.backend || result?.backend || null,
-        status: result?.status || (heartbeatMtime ? 'running' : 'launching'),
-        currentTask: result?.summary || null,
-        currentFile: Array.isArray(result?.changed_files) ? result.changed_files[0] : null,
-        patchStatus: Array.isArray(result?.patch_envelopes) && result.patch_envelopes.length ? 'candidate' : 'queued',
+        sessionId: result?.session_id || intake?.agent?.session_id || backendReport?.session_id || null,
+        role: input.role || result?.persona_id || intake?.agent?.naruto_role || intake?.agent?.role || intake?.agent?.persona_id || result?.agent_id || null,
+        backend: input.backend || result?.backend || backendReport?.selected_backend || intake?.backend || null,
+        status: result?.status || statusFromEvents(eventRows) || (heartbeatMtime ? 'running' : 'launching'),
+        fastMode: firstDefined(fastReport?.fast_mode, backendReport?.fast_mode, result?.fast_mode, intake?.fast_mode),
+        serviceTier: firstText([
+            fastReport?.service_tier,
+            paneReport?.service_tier,
+            backendReport?.service_tier,
+            codexProof?.config?.service_tier,
+            result?.service_tier,
+            intake?.service_tier
+        ]),
+        provider: firstText([
+            paneReport?.provider_context?.provider,
+            paneReport?.provider,
+            codexProof?.config?.model_provider,
+            localProof?.provider
+        ]),
+        authMode: firstText([
+            paneReport?.provider_context?.auth_mode,
+            codexProof?.config?.model_provider ? 'api_key' : null
+        ]),
+        model: firstText([
+            codexProof?.config?.model,
+            localProof?.model,
+            intake?.ollama_model,
+            intake?.local_model_model
+        ]),
+        reasoningEffort: firstText([
+            codexProof?.config?.model_reasoning_effort,
+            intake?.agent?.model_reasoning_effort,
+            intake?.agent?.reasoning_effort
+        ]),
+        currentTask: firstText([
+            result?.summary,
+            intake?.slice?.description,
+            intake?.slice?.title,
+            intake?.slice?.id,
+            lastEventLine(eventRows)
+        ]),
+        currentFile: changedFiles[0] || patchFiles[0] || plannedFiles[0] || null,
+        changedFiles,
+        plannedFiles,
+        patchFiles,
+        patchStatus: patchStatus(result, patch, patchFiles),
         verifyStatus: result?.verification?.status || 'queued',
         heartbeatAgeMs: heartbeatMtime ? now - heartbeatMtime : null,
-        worktreeId: result?.worktree?.id || null,
+        heartbeatEvent: heartbeatRows.length ? formatArtifactEvent(heartbeatRows[heartbeatRows.length - 1]) : null,
+        worktreeId: result?.worktree?.id || intake?.worktree?.id || null,
+        eventLines: eventRows.map(formatArtifactEvent).filter(Boolean),
+        stdoutTail: await readTextTailLines(path.join(artifactDir, 'worker.stdout.log'), 2),
+        stderrTail: await readTextTailLines(path.join(artifactDir, 'worker.stderr.log'), 1),
         mode: input.mode || 'compact-slots'
     });
 }
@@ -62,6 +143,14 @@ async function readJson(file) {
         return null;
     }
 }
+async function firstJson(files) {
+    for (const file of files) {
+        const value = await readJson(file);
+        if (value)
+            return value;
+    }
+    return null;
+}
 async function statMtimeMs(file) {
     try {
         return (await fs.promises.stat(file)).mtimeMs;
@@ -70,12 +159,166 @@ async function statMtimeMs(file) {
         return null;
     }
 }
+async function readJsonlTails(files, max) {
+    const rows = [];
+    for (const file of files)
+        rows.push(...await readJsonlTail(file, max));
+    return rows
+        .sort((a, b) => timestampMs(a) - timestampMs(b))
+        .slice(-max);
+}
+async function readJsonlTail(file, max) {
+    try {
+        const lines = (await fs.promises.readFile(file, 'utf8')).split(/\r?\n/).filter((line) => line.trim());
+        return lines.slice(-Math.max(1, max)).map((line) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return { message: line };
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+}
+async function readTextTailLines(file, max) {
+    try {
+        const lines = (await fs.promises.readFile(file, 'utf8')).split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+        return lines.slice(-Math.max(1, max));
+    }
+    catch {
+        return [];
+    }
+}
+function patchStatus(result, patch, files) {
+    const resultCount = Array.isArray(result?.patch_envelopes) ? result.patch_envelopes.length : 0;
+    const patchCount = Number(patch?.envelope_count || (Array.isArray(patch?.envelopes) ? patch.envelopes.length : 0));
+    const count = Math.max(resultCount, Number.isFinite(patchCount) ? patchCount : 0);
+    if (count > 0)
+        return `candidate (${count})`;
+    if (files.length)
+        return 'candidate';
+    return 'queued';
+}
+function patchPaths(value) {
+    const envelopes = [
+        ...(Array.isArray(value?.envelopes) ? value.envelopes : []),
+        ...(Array.isArray(value?.patch_envelopes) ? value.patch_envelopes : [])
+    ];
+    return normalizeList(envelopes.flatMap((envelope) => {
+        const paths = [
+            ...(Array.isArray(envelope?.operations) ? envelope.operations.map((operation) => operation?.path) : []),
+            ...(Array.isArray(envelope?.allowed_paths) ? envelope.allowed_paths : [])
+        ];
+        return paths;
+    }));
+}
+function statusFromEvents(rows) {
+    const last = rows[rows.length - 1];
+    const status = String(last?.lane_status || last?.status || '').trim();
+    if (status)
+        return status;
+    const type = String(last?.event_type || last?.type || '').trim();
+    if (/failed|blocked/i.test(type))
+        return 'blocked';
+    if (/completed|finished|closed/i.test(type))
+        return 'done';
+    if (type)
+        return 'running';
+    return null;
+}
+function lastEventLine(rows) {
+    for (const row of [...rows].reverse()) {
+        const text = formatArtifactEvent(row);
+        if (text)
+            return text;
+    }
+    return null;
+}
+function formatArtifactEvent(row) {
+    if (!row)
+        return '';
+    const status = trimInline(row.lane_status || row.status || row.event || row.event_type || row.type || row.sdk_event_type || 'event', 18);
+    const detail = firstText([
+        row.current_tool && row.current_file ? `tool ${row.current_tool} file ${row.current_file}` : null,
+        row.current_file ? `file ${row.current_file}` : null,
+        row.current_tool ? `tool ${row.current_tool}` : null,
+        row.message_tail,
+        row.blocker ? `blocker ${row.blocker}` : null,
+        row.request_id,
+        row.pane_id ? `pane ${row.pane_id}` : null,
+        row.message,
+        row.reason
+    ]);
+    return trimInline(detail ? `${status}: ${detail}` : status, 96);
+}
+function timestampMs(row) {
+    const raw = row?.ts || row?.generated_at || row?.updated_at || row?.created_at;
+    const parsed = raw ? Date.parse(String(raw)) : NaN;
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function firstText(values) {
+    for (const value of values) {
+        const text = String(value || '').replace(/\s+/g, ' ').trim();
+        if (text)
+            return text;
+    }
+    return null;
+}
+function firstDefined(...values) {
+    for (const value of values) {
+        if (value === true || value === false)
+            return value;
+        if (typeof value === 'string' && value.trim())
+            return value;
+        if (typeof value === 'number' && Number.isFinite(value))
+            return String(value);
+    }
+    return null;
+}
+function firstNonEmptyList(...values) {
+    for (const value of values) {
+        const normalized = normalizeList(value || []);
+        if (normalized.length)
+            return normalized;
+    }
+    return [];
+}
+function normalizeList(values) {
+    return [...new Set((Array.isArray(values) ? values : [values]).map((value) => String(value || '').trim()).filter(Boolean))];
+}
 function trimInline(value, max) {
     const text = String(value || '').replace(/\s+/g, ' ').trim();
     if (text.length <= max)
         return text;
     return text.slice(0, Math.max(1, max - 3)) + '...';
 }
+function formatFastMode(value, serviceTier) {
+    const text = String(value ?? '').trim().toLowerCase();
+    if (value === true || text === 'true' || text === '1' || text === 'on' || text === 'fast')
+        return 'on';
+    if (value === false || text === 'false' || text === '0' || text === 'off' || text === 'standard')
+        return 'off';
+    const tier = String(serviceTier || '').trim().toLowerCase();
+    if (tier === 'fast' || tier === 'priority')
+        return 'on';
+    if (tier === 'standard' || tier === 'default')
+        return 'off';
+    return 'unknown';
+}
+function frameSlotPane(title, rows) {
+    const width = Math.min(96, Math.max(44, title.length + 6, ...rows.map((row) => row.length + 4)));
+    const line = '+' + '-'.repeat(width - 2) + '+';
+    const label = ` ${trimInline(title, width - 4)} `;
+    const titleLine = '|' + label.padEnd(width - 2, ' ') + '|';
+    const body = rows.map((row) => {
+        const text = ` ${trimInline(row, width - 4)} `;
+        return '|' + text.padEnd(width - 2, ' ') + '|';
+    });
+    return [line, titleLine, line, ...body, line].join('\n');
+}
 function shellQuote(value) {
     return `'${String(value).replace(/'/g, `'\\''`)}'`;
 }

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

@@ -1,8 +1,47 @@
 #!/usr/bin/env node
 // @ts-nocheck
-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');
-emitGate('codex-sdk:research-pipeline', { route: '$Research' });
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist, readText } from './lib/codex-sdk-gate-lib.js';
+const researchCommand = readText('src/core/commands/research-command.ts');
+assertGate(researchCommand.includes("backend: mock ? 'fake' : 'codex-sdk'"), 'Research pipeline must default native agents to codex-sdk');
+assertGate(researchCommand.includes("flag(args, '--autoresearch') ? '$AutoResearch' : '$Research'"), 'Research/AutoResearch route selection missing');
+assertGate(researchCommand.includes('narutoWorkGraph: researchWorkGraph'), 'Research pipeline must pass the stage-aware Naruto work graph');
+assertGate(researchCommand.includes('readonly: true'), 'Research pipeline must force read-only native orchestration');
+assertGate(researchCommand.includes('quality_metrics'), 'Research pipeline JSON output must include quality metrics');
+assertGate(researchCommand.includes('const cycleResult = await runResearchCycle({'), 'Research default path must use runResearchCycle');
+assertGate(researchCommand.includes('--legacy-research-cycle'), 'Legacy final.md loop must be opt-in only');
+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');
+for (const [file, tokens] of Object.entries({
+    'src/core/research/research-work-graph.ts': ['buildResearchWorkGraph', 'source_shard_academic_literature'],
+    'src/core/research/research-cycle-runner.ts': ['runResearchCycle', 'Promise.race'],
+    'src/core/research/research-final-reviewer.ts': ['runResearchCodexFinalReviewer'],
+    'src/core/research/claim-evidence-matrix.ts': ['claim-evidence-matrix'],
+    'src/core/research/implementation-blueprint.ts': ['implementation-blueprint'],
+    'src/core/research/research-quality-contract.ts': ['research-quality-contract']
+})) {
+    const text = readText(file);
+    for (const token of tokens)
+        assertGate(text.includes(token), `${file} missing token ${token}`);
+}
+const research = await importDist('core/research.js');
+const fsx = await importDist('core/fsx.js');
+const dirShort = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-codex-research-short-'));
+const planShort = await research.writeResearchPlan(dirShort, 'codex sdk short rejection fixture', { missionId: 'M-CODEX-SHORT' });
+await fsx.writeTextAtomic(path.join(dirShort, 'research-report.md'), `# Short Report\n\n${Array.from({ length: 300 }, (_unused, index) => `word${index}`).join(' ')}\n`);
+await fsx.writeJsonAtomic(path.join(dirShort, 'source-ledger.json'), { schema_version: 1, web_search_passes: 1, source_layers: [], sources: [], counterevidence_sources: [], triangulation: { cross_layer_checks: [] }, citation_coverage: { all_key_claims_cited: false }, blockers: [] });
+await fsx.writeJsonAtomic(path.join(dirShort, 'implementation-blueprint.json'), { schema: 'sks.research-implementation-blueprint.v1', sections: [] });
+const shortGate = await research.evaluateResearchGate(dirShort);
+assertGate(shortGate.passed === false, 'codex-sdk research pipeline must reject short report fixture', shortGate);
+assertGate((shortGate.reasons || []).includes('research_report_too_short'), 'short rejection must include report length reason', shortGate);
+const dirComplete = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-codex-research-complete-'));
+const planComplete = await research.writeResearchPlan(dirComplete, 'codex sdk complete package fixture', { missionId: 'M-CODEX-COMPLETE' });
+const completeGate = await research.writeMockResearchResult(dirComplete, planComplete);
+assertGate(completeGate.passed === true, 'codex-sdk research pipeline must pass complete package fixture', completeGate);
+assertGate(completeGate.metrics?.final_review_approved === true, 'complete package must include approved final review', completeGate.metrics);
+emitGate('codex-sdk:research-pipeline', { route: '$Research', short_dir: dirShort, complete_dir: dirComplete });
 //# sourceMappingURL=codex-sdk-research-pipeline-check.js.map

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

@@ -29,7 +29,20 @@ const requiredReleasePresetIds = [
     'git:worktree-cross-rebase',
     'local-collab:worktree-gpt-final-apply-policy',
     'release:cache-glob-hashing',
-    'release:dag-full-coverage'
+    'release:dag-full-coverage',
+    'research:quality-contract',
+    'research:claim-matrix',
+    'research:source-quality-report',
+    'research:implementation-blueprint',
+    'research:experiment-plan',
+    'research:replication-pack',
+    'research:final-reviewer',
+    'research:work-graph',
+    'research:short-report-rejection',
+    'research:complete-package-fixture',
+    'research:stage-cycle-runtime-blackbox',
+    'research:final-reviewer-blackbox',
+    'codex-sdk:research-pipeline'
 ];
 const missing = legacyIds.filter((id) => !gateIds.has(id) && !allowlist.has(id));
 const missingRequiredReleasePreset = requiredReleasePresetIds.filter((id) => !gateIds.has(id) || !releasePresetIds.has(id));

package/dist/scripts/release-parallel-speed-budget-check.js

@@ -12,12 +12,15 @@ const summary = JSON.parse(fs.readFileSync(latest.summaryPath, 'utf8'));
 const slowest = slowestGateResults(latest.dir);
 const warnOnly = process.env.SKS_RELEASE_SPEED_BUDGET_WARN_ONLY === '1';
 const budgetMs = Number(process.env.SKS_RELEASE_SPEED_BUDGET_MS || 20 * 60 * 1000);
-const cachedBudgetMs = 3 * 60 * 1000;
+const cachedBudgetMs = Number(process.env.SKS_RELEASE_CACHED_SPEED_BUDGET_MS || 4 * 60 * 1000);
 const cachedRatio = Number(summary.cached || 0) / Math.max(1, Number(summary.completed || summary.selected_gates || 1));
 const cachedRun = cachedRatio >= 0.5;
 const parallelismOk = cachedRun || summary.parallelism_gain >= 2;
 const wallOk = cachedRun ? summary.wall_ms <= cachedBudgetMs : summary.wall_ms <= budgetMs;
-const summaryOk = Number(summary.failed || 0) === 0;
+const failureIds = Array.isArray(summary.failures) ? summary.failures.map((entry) => String(entry?.id || '')).filter(Boolean) : [];
+const selfFailureIds = new Set(['release:parallel-speed-budget', 'release:stability-report']);
+const blockingFailureIds = failureIds.filter((id) => !selfFailureIds.has(id));
+const summaryOk = Number(summary.failed || 0) === 0 || (failureIds.length > 0 && blockingFailureIds.length === 0);
 const report = {
     schema: 'sks.release-speed.v1',
     ok: summaryOk && parallelismOk && (wallOk || warnOnly),
@@ -34,6 +37,8 @@ const report = {
     sum_gate_ms: summary.sum_gate_ms,
     critical_path_ms: summary.critical_path_ms,
     slowest_gates: slowest,
+    functional_failure_ids: blockingFailureIds,
+    ignored_self_failure_ids: failureIds.filter((id) => selfFailureIds.has(id)),
     target_full_wall_ms: budgetMs,
     target_cached_wall_ms: cachedBudgetMs,
     target_changed_file_wall_ms: 90 * 1000,

package/dist/scripts/research-blueprint-densifier-check.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const research = await importDist('core/research.js');
+const workGraph = await importDist('core/research/research-work-graph.js');
+const cycleRunner = await importDist('core/research/research-cycle-runner.js');
+const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-blueprint-'));
+const plan = await research.writeResearchPlan(dir, 'blueprint densifier blackbox', { missionId: 'M-BLUEPRINT' });
+const graph = workGraph.buildResearchWorkGraph(plan);
+await cycleRunner.runResearchCycle({ root: process.cwd(), dir, plan, graph, cycle: 1, backend: 'mock', timeoutMs: 120000, maxParallelStages: 4, mock: true });
+const blueprint = JSON.parse(fs.readFileSync(path.join(dir, 'implementation-blueprint.json'), 'utf8'));
+assertGate(blueprint.repository_aware === true, 'blueprint must be repository-aware', blueprint);
+assertGate((blueprint.existing_files || []).length > 0, 'blueprint must list concrete existing files', blueprint);
+assertGate((blueprint.sections || []).length >= 8, 'blueprint must keep required sections', blueprint);
+assertGate((blueprint.test_commands || []).some((cmd) => String(cmd).includes('research:stage-cycle-runtime-blackbox')), 'blueprint must include concrete test commands', blueprint);
+assertGate(fs.existsSync(path.join(dir, 'team-handoff-goal.md')), 'team handoff goal must exist');
+emitGate('research:blueprint-densifier', { dir, sections: blueprint.sections.length, files: blueprint.existing_files.length });
+//# sourceMappingURL=research-blueprint-densifier-check.js.map

package/dist/scripts/research-claim-builder-check.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const research = await importDist('core/research.js');
+const workGraph = await importDist('core/research/research-work-graph.js');
+const cycleRunner = await importDist('core/research/research-cycle-runner.js');
+const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-claim-builder-'));
+const plan = await research.writeResearchPlan(dir, 'claim builder blackbox', { missionId: 'M-CLAIM-BUILDER' });
+const graph = workGraph.buildResearchWorkGraph(plan);
+await cycleRunner.runResearchCycle({ root: process.cwd(), dir, plan, graph, cycle: 1, backend: 'mock', timeoutMs: 120000, maxParallelStages: 4, mock: true });
+const matrix = JSON.parse(fs.readFileSync(path.join(dir, 'claim-evidence-matrix.json'), 'utf8'));
+assertGate(matrix.key_claim_ids.length >= 8, 'claim builder must produce key claims', matrix);
+assertGate(matrix.triangulated_claim_count >= 6, 'claim builder must triangulate claims', matrix);
+assertGate((matrix.unsupported_claims || []).length === 0, 'claim builder must not leave important claims unsupported in complete fixture', matrix);
+emitGate('research:claim-builder', { dir, key_claims: matrix.key_claim_ids.length, triangulated: matrix.triangulated_claim_count });
+//# sourceMappingURL=research-claim-builder-check.js.map

package/dist/scripts/research-complete-package-fixture-check.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const research = await importDist('core/research.js');
+const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-complete-package-'));
+const plan = await research.writeResearchPlan(dir, 'complete package fixture blackbox', { missionId: 'M-COMPLETE-PACKAGE' });
+const gate = await research.writeMockResearchResult(dir, plan);
+const metrics = gate.metrics || {};
+assertGate(gate.passed === true, 'complete mock research package must pass', gate);
+assertGate(metrics.report_word_count >= 2200, 'report must satisfy word floor', metrics);
+assertGate(metrics.source_entries_total_with_counterevidence >= 12, 'source count must satisfy contract', metrics);
+assertGate(metrics.source_layers_covered >= 5, 'source layer coverage must satisfy contract', metrics);
+assertGate(metrics.key_claims >= 8, 'key claims must satisfy contract', metrics);
+assertGate(metrics.counterevidence_sources >= 2, 'counterevidence count must satisfy contract', metrics);
+assertGate(metrics.final_review_approved === true, 'static plus mock Codex final review must approve', metrics);
+assertGate(metrics.implementation_blueprint_validation?.ok === true, 'blueprint must validate', metrics);
+assertGate(metrics.experiment_plan_validation?.ok === true, 'experiment plan must validate', metrics);
+assertGate(metrics.replication_pack_validation?.ok === true, 'replication pack must validate', metrics);
+emitGate('research:complete-package-fixture', { dir, metrics });
+//# sourceMappingURL=research-complete-package-fixture-check.js.map

package/dist/scripts/research-final-reviewer-blackbox.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const research = await importDist('core/research.js');
+const reviewer = await importDist('core/research/research-final-reviewer.js');
+const fsx = await importDist('core/fsx.js');
+const badDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-final-review-bad-'));
+await research.writeResearchPlan(badDir, 'bad final reviewer fixture', { missionId: 'M-FINAL-BAD' });
+await fsx.writeTextAtomic(path.join(badDir, 'research-report.md'), '# Bad\n\nToo short.\n');
+const bad = await reviewer.runResearchFinalReviewer(badDir, { codexRequired: true });
+assertGate(bad.approved === false, 'static failure must not approve final review', bad);
+const goodDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-final-review-good-'));
+const plan = await research.writeResearchPlan(goodDir, 'good final reviewer fixture', { missionId: 'M-FINAL-GOOD' });
+await research.writeMockResearchResult(goodDir, plan);
+const good = JSON.parse(fs.readFileSync(path.join(goodDir, 'research-final-review.json'), 'utf8'));
+assertGate(good.approved === true, 'complete package must approve final review with mock Codex reviewer', good);
+assertGate(good.codex_review?.verdict === 'approve', 'merged final review must include Codex/mock approval', good);
+emitGate('research:final-reviewer-blackbox', { bad_dir: badDir, good_dir: goodDir });
+//# sourceMappingURL=research-final-reviewer-blackbox.js.map

package/dist/scripts/research-parallel-source-shards-check.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const workGraph = await importDist('core/research/research-work-graph.js');
+const graph = workGraph.buildResearchWorkGraph({ mission_id: 'M-PARALLEL-SHARDS' });
+const shards = graph.work_items.filter((item) => item.stage_kind === 'source_shard');
+const shardIds = new Set(shards.map((item) => item.id));
+const claim = graph.work_items.find((item) => item.id === 'claim_matrix_build');
+const merge = graph.work_items.find((item) => item.id === 'source_ledger_merge');
+assertGate(shards.length >= 8, 'work graph must create source layer shards', { count: shards.length });
+assertGate(shards.some((item) => item.id === 'source_shard_academic_literature'), 'academic source shard missing');
+assertGate(shards.some((item) => item.id === 'source_shard_official_government_data'), 'official government source shard missing');
+assertGate(shards.some((item) => item.id === 'source_shard_standards_primary_docs'), 'standards source shard missing');
+assertGate(shards.some((item) => item.id === 'source_shard_news_current_events'), 'news source shard missing');
+assertGate(shards.some((item) => item.id === 'source_shard_public_discourse'), 'public discourse source shard missing');
+assertGate(shards.some((item) => item.id === 'source_shard_developer_practitioner'), 'developer practitioner source shard missing');
+assertGate(shards.some((item) => item.id === 'source_shard_counterevidence_factcheck'), 'counterevidence source shard missing');
+assertGate(shards.some((item) => item.id === 'source_shard_local_project_evidence'), 'local project evidence source shard missing');
+assertGate(merge && merge.dependencies.every((id) => shardIds.has(id)), 'source merge must depend on every source shard', merge);
+assertGate(claim && [...shardIds].every((id) => claim.dependencies.includes(id)), 'claim matrix must depend on source shards', claim);
+emitGate('research:parallel-source-shards', { shard_count: shards.length });
+//# sourceMappingURL=research-parallel-source-shards-check.js.map