sneakoscope 2.0.12 → 2.0.13

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '2.0.12';
+export const PACKAGE_VERSION = '2.0.13';
 //# 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

@@ -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/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/research-quality-gate-check.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readText } from './lib/codex-sdk-gate-lib.js';
+const mode = process.argv[2] || 'all';
+const checks = {
+    'quality-contract': () => {
+        assertFileIncludes('src/core/research/research-quality-contract.ts', [
+            'min_sources_total: 12',
+            'min_source_layers_covered: 5',
+            'min_counterevidence_sources: 2',
+            'min_trianguled_claims: 6',
+            'min_key_claims: 8',
+            'min_report_words: 2200'
+        ]);
+        assertFileIncludes('src/core/research.ts', ['quality_contract', 'writeResearchQualityContract', 'research_report_too_short']);
+    },
+    'claim-matrix': () => {
+        assertFileIncludes('src/core/research/claim-evidence-matrix.ts', ['CLAIM_EVIDENCE_MATRIX_ARTIFACT', 'validateClaimEvidenceMatrix', 'buildClaimEvidenceMatrixFromLedgers']);
+        assertFileIncludes('src/core/research.ts', ['claim_evidence_matrix_missing', 'key_claims_below_contract', 'triangulated_claims_below_contract']);
+    },
+    'source-quality-report': () => {
+        assertFileIncludes('src/core/research/source-quality-report.ts', ['SOURCE_QUALITY_REPORT_ARTIFACT', 'buildSourceQualityReport', 'claim_ids']);
+        assertFileIncludes('src/core/research.ts', ['source_quality_report_missing', 'writeSourceQualityReport']);
+    },
+    'implementation-blueprint': () => {
+        assertFileIncludes('src/core/research/implementation-blueprint.ts', ['IMPLEMENTATION_BLUEPRINT_ARTIFACT', 'validateImplementationBlueprint']);
+        assertFileIncludes('src/core/research.ts', ['implementation_blueprint_missing', 'renderImplementationBlueprintMarkdown']);
+    },
+    'experiment-plan': () => {
+        assertFileIncludes('src/core/research/experiment-plan.ts', ['EXPERIMENT_PLAN_JSON_ARTIFACT', 'min_experiment_steps', 'validateExperimentPlan']);
+        assertFileIncludes('src/core/research/experiment-plan.ts', ['experiment_plan_missing', 'experiment_plan_too_thin']);
+        assertFileIncludes('src/core/research.ts', ['experiment_plan_missing', 'validateExperimentPlan']);
+    },
+    'replication-pack': () => {
+        assertFileIncludes('src/core/research/replication-pack.ts', ['REPLICATION_PACK_ARTIFACT', 'validateReplicationPack']);
+        assertFileIncludes('src/core/research.ts', ['replication_pack_missing']);
+    },
+    'final-reviewer': () => {
+        assertFileIncludes('src/core/research/research-final-reviewer.ts', ['RESEARCH_FINAL_REVIEW_ARTIFACT', 'approved', 'runResearchFinalReviewer']);
+        assertFileIncludes('src/core/research.ts', ['research_final_review_not_approved']);
+    },
+    'work-graph': () => {
+        assertFileIncludes('src/core/research/research-work-graph.ts', ['RESEARCH_WORK_GRAPH_ARTIFACT', 'buildResearchWorkGraph', 'sks.naruto-work-graph.v1']);
+        assertFileIncludes('src/core/commands/research-command.ts', ['narutoWorkGraph: researchWorkGraph', 'readonly: true', 'runResearchCycle']);
+    },
+    'prompt-contract': () => {
+        assertFileIncludes('src/core/research/research-prompt-contract.ts', ['researchPromptContractText', 'validateResearchPromptContract']);
+        assertFileIncludes('src/core/research.ts', ['QUALITY CONTRACT:', 'researchPromptContractText()']);
+    },
+    'gate-thresholds': () => {
+        assertFileIncludes('src/core/research.ts', [
+            'source_entries_below_research_quality_contract',
+            'source_layer_coverage_below_contract',
+            'counterevidence_below_contract',
+            'required_artifact_missing'
+        ]);
+        assertFileIncludes('src/core/research/falsification.ts', ['falsification_cases_below_contract']);
+    },
+    'schemas': () => {
+        for (const file of [
+            'schemas/research/research-quality-contract.schema.json',
+            'schemas/research/claim-evidence-matrix.schema.json',
+            'schemas/research/source-quality-report.schema.json',
+            'schemas/research/implementation-blueprint.schema.json',
+            'schemas/research/experiment-plan.schema.json',
+            'schemas/research/replication-pack.schema.json',
+            'schemas/research/research-final-review.schema.json'
+        ])
+            assertGate(readText(file).includes('"$schema"'), `${file} missing JSON Schema header`);
+    }
+};
+if (mode === 'all') {
+    for (const check of Object.values(checks))
+        check();
+}
+else {
+    assertGate(Boolean(checks[mode]), `unknown research quality check: ${mode}`);
+    checks[mode]();
+}
+emitGate(`research:${mode}`, { mode });
+function assertFileIncludes(file, tokens) {
+    const text = readText(file);
+    for (const token of tokens)
+        assertGate(text.includes(token), `${file} missing token ${token}`);
+}
+//# sourceMappingURL=research-quality-gate-check.js.map

package/dist/scripts/zellij-slot-column-anchor-check.js

@@ -26,6 +26,24 @@ const roster = renderZellijSlotColumnAnchor({
         }
     ]
 });
+const overflow = renderZellijSlotColumnAnchor({
+    activeWorkers: 6,
+    visiblePaneCap: 5,
+    headlessWorkers: 1,
+    queueDepth: 0,
+    mode: 'compact-slots',
+    workerRows: [
+        {
+            slotId: 'slot-009',
+            generationIndex: 1,
+            placement: 'headless',
+            status: 'running',
+            backend: 'local-llm',
+            task: 'Waiting for a visible slot pane',
+            heartbeatAgeMs: 1200
+        }
+    ]
+});
 const command = buildZellijSlotColumnAnchorCommand({
     nodePath: '/usr/bin/node',
     cliPath: '/repo/dist/bin/sks.js',
@@ -34,12 +52,15 @@ const command = buildZellijSlotColumnAnchorCommand({
     artifactRoot: '/repo/.sneakoscope/missions/M-check/agents',
     watch: true
 });
-const ok = rendered === 'SLOTS active 3/8 · headless 12 · q 44'
+const ok = rendered.includes('SLOTS active 3/8 · headless 12 · q 44')
+    && rendered.includes('visible slot panes stack below this anchor')
     && roster.includes('SLOTS active 1/5 · headless 0 · q 0')
-    && roster.includes('slot-004 g1 running codex-sdk')
-    && roster.includes('Inspect Zellij slot UI assignment')
+    && roster.includes('visible slot panes stack below this anchor')
+    && !roster.includes('slot-004 g1 running codex-sdk')
+    && overflow.includes('slot-009 g1 running local-llm')
+    && overflow.includes('Waiting for a visible slot pane')
     && command.includes('zellij-slot-column-anchor')
     && command.includes('--watch');
-assertGate(ok, 'Zellij slot-column anchor must render compact SLOTS header plus live worker rows and build the CLI command', { rendered, roster, command });
-emitGate('zellij:slot-column-anchor', { rendered, roster, command });
+assertGate(ok, 'Zellij slot-column anchor must stay an anchor while slot workers render in dedicated stacked panes', { rendered, roster, overflow, command });
+emitGate('zellij:slot-column-anchor', { rendered, roster, overflow, command });
 //# sourceMappingURL=zellij-slot-column-anchor-check.js.map

package/dist/scripts/zellij-slot-pane-renderer-check.js

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
 // @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
 import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
 const renderer = await importDist('core/zellij/zellij-slot-pane-renderer.js');
 const text = renderer.renderZellijSlotPane({
@@ -8,14 +11,72 @@ const text = renderer.renderZellijSlotPane({
     role: 'implementer',
     backend: 'local-llm',
     status: 'coding',
+    fastMode: true,
+    serviceTier: 'fast',
+    provider: 'codex-lb',
+    authMode: 'codex_lb_key',
+    model: 'gpt-5.5',
+    reasoningEffort: 'medium',
     currentFile: 'src/core/foo.ts',
+    currentTask: 'Editing Zellij slot pane renderer',
+    changedFiles: ['src/core/foo.ts', 'src/core/bar.ts'],
     patchStatus: 'candidate',
     verifyStatus: 'queued',
     heartbeatAgeMs: 2000,
     worktreeId: 'WT-0007',
+    eventLines: ['running: tool apply_patch', 'running: file src/core/foo.ts'],
+    stdoutTail: ['renderer updated live pane output'],
     mode: 'compact-slots'
 });
 const lines = text.split(/\n/);
+const artifactDir = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-slot-pane-renderer-'));
+await fs.writeFile(path.join(artifactDir, 'worker-intake.json'), JSON.stringify({
+    agent: { session_id: 'session-slot-003', role: 'implementer' },
+    backend: 'codex-sdk',
+    fast_mode: true,
+    service_tier: 'fast',
+    slice: {
+        title: 'Hydrate live slot pane from artifacts',
+        write_paths: ['src/core/zellij/zellij-slot-pane-renderer.ts']
+    },
+    worktree: { id: 'WT-0007' }
+}, null, 2));
+await fs.writeFile(path.join(artifactDir, 'worker-fast-mode.json'), JSON.stringify({
+    fast_mode: true,
+    service_tier: 'fast'
+}, null, 2));
+await fs.writeFile(path.join(artifactDir, 'zellij-worker-pane.json'), JSON.stringify({
+    provider: 'codex-lb',
+    service_tier: 'fast',
+    provider_context: {
+        provider: 'codex-lb',
+        auth_mode: 'codex_lb_key'
+    }
+}, null, 2));
+await fs.writeFile(path.join(artifactDir, 'codex-control-proof.json'), JSON.stringify({
+    config: {
+        model: 'gpt-5.5',
+        model_provider: 'codex-lb',
+        service_tier: 'fast',
+        model_reasoning_effort: 'medium'
+    }
+}, null, 2));
+await fs.writeFile(path.join(artifactDir, 'worker-heartbeat.jsonl'), `${JSON.stringify({ event: 'started', status: 'running' })}\n`);
+await fs.writeFile(path.join(artifactDir, 'codex-sdk-events.jsonl'), `${JSON.stringify({
+    sdk_event_type: 'item.completed',
+    lane_status: 'running',
+    current_tool: 'apply_patch',
+    current_file: 'src/core/zellij/zellij-slot-pane-renderer.ts',
+    message_tail: null
+})}\n`);
+await fs.writeFile(path.join(artifactDir, 'worker.stdout.log'), 'renderer stdout tail\n');
+const hydrated = await renderer.renderZellijSlotPaneFromArtifacts({
+    artifactDir,
+    slotId: 'slot-003',
+    generationIndex: 2,
+    mode: 'compact-slots'
+});
+await fs.rm(artifactDir, { recursive: true, force: true });
 const command = renderer.buildZellijSlotPaneCommand({
     cliPath: '/repo/dist/bin/sks.js',
     missionId: 'M-test',
@@ -27,12 +88,19 @@ const command = renderer.buildZellijSlotPaneCommand({
 const report = {
     schema: 'sks.zellij-slot-pane-renderer-check.v1',
     line_count: lines.length,
-    max_compact_lines: 5,
-    contains_slot: /slot-003 gen-2/.test(text),
-    contains_status: /status: coding/.test(text),
+    max_compact_lines: 17,
+    contains_slot: /LIVE SLOT slot-003/.test(text) && /slot: slot-003 \/ gen-2/.test(text),
+    contains_status: /coding/.test(text),
+    contains_runtime: /runtime: fast on/.test(text) && /model: gpt-5\.5/.test(text) && /provider: codex-lb/.test(text),
+    contains_files: /src\/core\/foo\.ts/.test(text) && /src\/core\/bar\.ts/.test(text),
+    contains_live_event: /event: running:/.test(text),
+    artifact_hydrates_runtime: /runtime: fast on/.test(hydrated) && /model: gpt-5\.5/.test(hydrated) && /reasoning: medium/.test(hydrated) && /auth: codex_lb_key/.test(hydrated),
+    artifact_hydrates_live_event: /tool apply_patch/.test(hydrated) && /renderer stdout tail/.test(hydrated),
+    artifact_hydrates_planned_file: /zellij-slot-pane-renderer\.ts/.test(hydrated),
     command_uses_slot_pane: command.includes('zellij-slot-pane') && command.includes('--watch'),
-    snapshot: text
+    snapshot: text,
+    hydrated_snapshot: hydrated
 };
-assertGate(lines.length <= 5 && report.contains_slot && report.contains_status && report.command_uses_slot_pane, 'compact slot pane renderer must stay within five lines', report);
+assertGate(lines.length <= 17 && report.contains_slot && report.contains_status && report.contains_runtime && report.contains_files && report.contains_live_event && report.artifact_hydrates_runtime && report.artifact_hydrates_live_event && report.artifact_hydrates_planned_file && report.command_uses_slot_pane, 'compact slot pane renderer must render one live work pane per slot', report);
 emitGate('zellij:compact-slot-renderer', report);
 //# sourceMappingURL=zellij-slot-pane-renderer-check.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "2.0.12",
+  "version": "2.0.13",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -394,6 +394,18 @@
     "agent:proof-graph": "node ./dist/scripts/agent-native-release-gate.js agent-proof-graph",
     "team:native-agent-backend": "node ./dist/scripts/agent-native-release-gate.js team-native-agent-backend",
     "research:native-agent-backend": "node ./dist/scripts/agent-native-release-gate.js research-native-agent-backend",
+    "research:quality-contract": "node ./dist/scripts/research-quality-gate-check.js quality-contract",
+    "research:claim-matrix": "node ./dist/scripts/research-quality-gate-check.js claim-matrix",
+    "research:source-quality-report": "node ./dist/scripts/research-quality-gate-check.js source-quality-report",
+    "research:implementation-blueprint": "node ./dist/scripts/research-quality-gate-check.js implementation-blueprint",
+    "research:experiment-plan": "node ./dist/scripts/research-quality-gate-check.js experiment-plan",
+    "research:replication-pack": "node ./dist/scripts/research-quality-gate-check.js replication-pack",
+    "research:final-reviewer": "node ./dist/scripts/research-quality-gate-check.js final-reviewer",
+    "research:work-graph": "node ./dist/scripts/research-quality-gate-check.js work-graph",
+    "research:prompt-contract": "node ./dist/scripts/research-quality-gate-check.js prompt-contract",
+    "research:gate-thresholds": "node ./dist/scripts/research-quality-gate-check.js gate-thresholds",
+    "research:schemas": "node ./dist/scripts/research-quality-gate-check.js schemas",
+    "research:quality-gates": "node ./dist/scripts/research-quality-gate-check.js all",
     "qa:native-agent-backend": "node ./dist/scripts/agent-native-release-gate.js qa-native-agent-backend",
     "agent:non-recursive-pipeline-report": "node ./dist/scripts/non-recursive-pipeline-check.js --json",
     "agent:legacy-multiagent-removed": "node ./dist/scripts/legacy-multiagent-removal-check.js",