sneakoscope 4.8.6 → 5.1.2

package/dist/core/agents/agent-patch-queue-store.js

@@ -1,7 +1,11 @@
 import path from 'node:path';
-import { appendJsonl, readJson, writeJsonAtomic } from '../fsx.js';
+import { appendJsonl, appendJsonlMany, ensureDir, readJson, writeJsonAtomic } from '../fsx.js';
 import { AGENT_PATCH_QUEUE_SCHEMA, InMemoryAgentPatchQueue, buildAgentPatchOwnershipLedger } from './agent-patch-queue.js';
 import { AgentPatchTransactionJournal } from './agent-patch-transaction-journal.js';
+import { normalizeAgentPatchEnvelope } from './agent-patch-schema.js';
+import { scanImpact } from '../verification/impact-scan.js';
+import { runMachineFeedback } from '../verification/machine-feedback.js';
+import { analyzeDiffQuality } from '../verification/diff-quality.js';
 export const AGENT_PATCH_QUEUE_ARTIFACT = 'agent-patch-queue.json';
 export const AGENT_PATCH_QUEUE_EVENTS_ARTIFACT = 'agent-patch-queue-events.jsonl';
 export const AGENT_PATCH_OWNERSHIP_LEDGER_ARTIFACT = 'agent-patch-ownership-ledger.json';
@@ -15,7 +19,13 @@ export class PersistentAgentPatchQueueStore {
         this.journal = new AgentPatchTransactionJournal(artifactDir);
     }
     async enqueue(input, context = {}) {
-        const entry = this.queue.enqueue(input, context);
+        const preflight = await this.runQualityPreflight(input, context);
+        const entry = this.queue.enqueue(input, {
+            ...(context.mission_id ? { mission_id: context.mission_id } : {}),
+            ...(context.route ? { route: context.route } : {}),
+            preflight_violations: preflight.violations,
+            preflight_reports: preflight.reports
+        });
         await this.persistSnapshot();
         await this.appendEvent(this.queue.events.at(-1));
         await this.journal.append({
@@ -29,9 +39,55 @@ export class PersistentAgentPatchQueueStore {
         });
         return entry;
     }
+    async runQualityPreflight(input, context = {}) {
+        const envelope = normalizeAgentPatchEnvelope(input);
+        const changedFiles = changedFilesForEnvelope(envelope);
+        const patchText = patchTextForEnvelope(envelope);
+        const root = envelope.git_worktree?.worktree_path || context.root || process.cwd();
+        const reportDir = path.join(this.artifactDir, 'patch-quality', safeName(`${envelope.agent_id}-${envelope.session_id}-${Date.now()}`));
+        await ensureDir(reportDir);
+        const [impact, diffQuality, feedback] = await Promise.all([
+            scanImpact(root, changedFiles, patchText).catch((err) => ({ schema: 'sks.impact-scan.v1', changed_symbols: [], references: [], cochange_required: [], tool: 'builtin', error: errorMessage(err) })),
+            analyzeDiffQuality({
+                root,
+                changedFiles,
+                patchText,
+                plannedFiles: envelope.allowed_paths || envelope.lease_proof?.allowed_paths || []
+            }).catch((err) => ({ schema: 'sks.diff-quality.v1', minimality: { plan_files: 0, touched_files: changedFiles.length, ratio: 1 }, dead_additions: [], comment_noise: 0, guard_bloat: 0, warnings: [], errors: [`diff_quality_failed:${errorMessage(err)}`] })),
+            runMachineFeedback(root, changedFiles, { timeoutMs: 60_000 }).catch((err) => ({ schema: 'sks.machine-feedback.v1', ok: false, typecheck: { ok: false, errors: [errorMessage(err)] }, lint: { ok: true, errors: [] }, tests: { ok: true, selected: [], failed: [], skipped_reason: 'machine_feedback_exception' }, duration_ms: 0 }))
+        ]);
+        await writeJsonAtomic(path.join(reportDir, 'impact-scan.json'), impact);
+        await writeJsonAtomic(path.join(reportDir, 'diff-quality.json'), diffQuality);
+        await writeJsonAtomic(path.join(reportDir, 'machine-feedback.json'), feedback);
+        const cochangeAck = envelope.cochange_acknowledged === true && String(envelope.cochange_acknowledged_reason || '').trim().length > 0;
+        const violations = [
+            ...(impact.cochange_required?.length && !cochangeAck ? [`impact_scan_cochange_missing:${impact.cochange_required.slice(0, 5).join(',')}`] : []),
+            ...((diffQuality.errors || []).map((issue) => `diff_quality:${issue}`)),
+            ...(feedback.ok === false ? ['machine_feedback_failed'] : []),
+            ...(isBugfixKind(context.work_item_kind, envelope.task_slice_id) && !validRegressionProof(envelope.regression_proof || context.regression_proof) ? ['tdd_evidence_missing'] : []),
+            ...(isRepairKind(context.work_item_kind, envelope.task_slice_id) && !(envelope.repair_hypothesis || context.repair_hypothesis) ? ['repair_without_hypothesis'] : [])
+        ];
+        return {
+            violations,
+            reports: {
+                impact_scan: path.relative(this.artifactDir, path.join(reportDir, 'impact-scan.json')),
+                diff_quality: path.relative(this.artifactDir, path.join(reportDir, 'diff-quality.json')),
+                machine_feedback: path.relative(this.artifactDir, path.join(reportDir, 'machine-feedback.json'))
+            }
+        };
+    }
     async markApplying(id) {
         await this.transition(id, () => this.queue.markApplying(id));
     }
+    async markApplyingBatch(ids) {
+        const uniqueIds = [...new Set(ids.map(String).filter(Boolean))];
+        if (!uniqueIds.length)
+            return;
+        const beforeEventCount = this.queue.events.length;
+        this.queue.markApplyingBatch(uniqueIds);
+        await this.persistSnapshot();
+        await this.appendEvents(this.queue.events.slice(beforeEventCount));
+    }
     async markApplied(id) {
         await this.transition(id, () => this.queue.markApplied(id));
     }
@@ -66,8 +122,7 @@ export class PersistentAgentPatchQueueStore {
         const beforeEventCount = this.queue.events.length;
         mutate();
         await this.persistSnapshot();
-        for (const event of this.queue.events.slice(beforeEventCount))
-            await this.appendEvent(event);
+        await this.appendEvents(this.queue.events.slice(beforeEventCount));
         const entry = this.queue.entries.find((item) => item.id === id);
         if (entry && ['verified', 'conflicted', 'rolled_back', 'rejected'].includes(entry.status)) {
             await this.journal.append({
@@ -86,5 +141,54 @@ export class PersistentAgentPatchQueueStore {
             return;
         await appendJsonl(path.join(this.artifactDir, AGENT_PATCH_QUEUE_EVENTS_ARTIFACT), event);
     }
+    async appendEvents(events) {
+        await appendJsonlMany(path.join(this.artifactDir, AGENT_PATCH_QUEUE_EVENTS_ARTIFACT), events.filter(Boolean));
+    }
+}
+function isBugfixKind(kind, id) {
+    const text = `${String(kind || '')} ${String(id || '')}`.toLowerCase();
+    return /\b(bugfix|fix|bug|regression|broken|failure|crash|error)\b|버그|회귀/.test(text);
+}
+function isRepairKind(kind, id) {
+    const text = `${String(kind || '')} ${String(id || '')}`.toLowerCase();
+    return /\b(conflict_resolution|repair|conflict|rebase|rollback)\b|수리|충돌/.test(text);
+}
+function validRegressionProof(proof) {
+    return Boolean(proof && proof.failed_before === true && proof.passed_after === true && String(proof.test_file || '').trim());
+}
+function changedFilesForEnvelope(envelope) {
+    const files = envelope.git_worktree?.changed_files?.length
+        ? envelope.git_worktree.changed_files
+        : envelope.operations.map((operation) => operation.path);
+    return [...new Set(files.map(normalizePath).filter(Boolean))];
+}
+function patchTextForEnvelope(envelope) {
+    return envelope.operations.map((operation) => {
+        if (operation.diff)
+            return operation.diff;
+        if (operation.op === 'replace')
+            return [
+                `--- a/${operation.path}`,
+                `+++ b/${operation.path}`,
+                `-${operation.search || ''}`,
+                `+${operation.replace || ''}`
+            ].join('\n');
+        if (operation.op === 'write')
+            return [
+                `--- /dev/null`,
+                `+++ b/${operation.path}`,
+                ...String(operation.content || '').split(/\r?\n/).map((line) => `+${line}`)
+            ].join('\n');
+        return '';
+    }).join('\n');
+}
+function normalizePath(value) {
+    return String(value || '').replace(/\\/g, '/').replace(/^\.\/+/, '');
+}
+function safeName(value) {
+    return String(value || 'patch').replace(/[^A-Za-z0-9_.-]+/g, '-').slice(0, 160);
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
 }
 //# sourceMappingURL=agent-patch-queue-store.js.map

package/dist/core/agents/agent-patch-queue.js

@@ -6,6 +6,7 @@ export class InMemoryAgentPatchQueue {
     enqueue(input, context = {}) {
         const envelope = normalizeAgentPatchEnvelope(input);
         const validation = validateAgentPatchEnvelope(envelope);
+        const preflightViolations = Array.isArray(context.preflight_violations) ? context.preflight_violations.map(String) : [];
         const now = new Date().toISOString();
         const leaseId = envelope.lease_id || envelope.lease_proof?.lease_id;
         const entry = {
@@ -19,8 +20,9 @@ export class InMemoryAgentPatchQueue {
             ...(leaseId ? { lease_id: leaseId } : {}),
             write_paths: envelope.operations.map((operation) => operation.path),
             envelope,
-            status: validation.ok ? 'pending' : 'rejected',
-            violations: validation.violations,
+            status: validation.ok && preflightViolations.length === 0 ? 'pending' : 'rejected',
+            violations: [...validation.violations, ...preflightViolations],
+            ...(context.preflight_reports ? { quality_reports: context.preflight_reports } : {}),
             created_at: now,
             updated_at: now
         };
@@ -34,6 +36,10 @@ export class InMemoryAgentPatchQueue {
     markApplying(id) {
         this.transition(id, 'applying');
     }
+    markApplyingBatch(ids) {
+        for (const id of ids)
+            this.transition(id, 'applying');
+    }
     markApplied(id) {
         this.transition(id, 'applied');
     }
@@ -93,7 +99,8 @@ export function buildAgentPatchOwnershipLedger(entries) {
         status: entry.status,
         created_at: entry.created_at,
         updated_at: entry.updated_at,
-        violations: [...entry.violations]
+        violations: [...entry.violations],
+        quality_reports: entry.quality_reports || null
     }));
 }
 //# sourceMappingURL=agent-patch-queue.js.map

package/dist/core/agents/agent-patch-schema.js

@@ -31,6 +31,11 @@ export function normalizeAgentPatchEnvelope(input) {
         ...(input?.rationale ? { rationale: String(input.rationale) } : {}),
         ...(input?.verification_hint ? { verification_hint: normalizeHint(input.verification_hint) } : {}),
         ...(input?.rollback_hint ? { rollback_hint: normalizeHint(input.rollback_hint) } : {}),
+        ...(input?.cochange_acknowledged === undefined ? {} : { cochange_acknowledged: Boolean(input.cochange_acknowledged) }),
+        ...(input?.cochange_acknowledged_reason === undefined ? {} : { cochange_acknowledged_reason: String(input.cochange_acknowledged_reason) }),
+        ...(input?.regression_proof ? { regression_proof: normalizeRegressionProof(input.regression_proof) } : {}),
+        ...(input?.repair_hypothesis && typeof input.repair_hypothesis === 'object' ? { repair_hypothesis: input.repair_hypothesis } : {}),
+        ...(input?.tournament && typeof input.tournament === 'object' ? { tournament: input.tournament } : {}),
         operations: Array.isArray(input?.operations) ? input.operations.map(normalizeOperation) : []
     };
 }
@@ -135,6 +140,14 @@ function normalizeHint(input) {
         ...(input?.notes === undefined ? {} : { notes: String(input.notes) })
     };
 }
+function normalizeRegressionProof(input) {
+    return {
+        ...(input?.test_file === undefined ? {} : { test_file: String(input.test_file) }),
+        ...(input?.failed_before === undefined ? {} : { failed_before: Boolean(input.failed_before) }),
+        ...(input?.passed_after === undefined ? {} : { passed_after: Boolean(input.passed_after) }),
+        ...(input?.output_digest === undefined ? {} : { output_digest: String(input.output_digest) })
+    };
+}
 function pathAllowedByLease(operationPath, allowedPaths) {
     const rel = normalizePatchPath(operationPath);
     return allowedPaths.map(normalizePatchPath).some((allowed) => rel === allowed || rel.startsWith(`${allowed}/`));

package/dist/core/agents/agent-proof-evidence.js

@@ -129,6 +129,11 @@ export async function writeAgentProofEvidence(root, input) {
         narutoWorkGraph
     });
     const changedFileLeaseBlockers = readOnlyNoWriteLeaseMode ? [] : agentChangedFileLeaseViolations(input.results || [], input.partition?.leases || []);
+    const schedulerBackfillSatisfied = !scheduler
+        || Number(scheduler.expected_backfill_count || 0) <= Number(scheduler.backfill_count || 0)
+        || (scheduler.pending_queue_drained === true
+            && Number(scheduler.active_slot_count || 0) === 0
+            && Number(scheduler.max_observed_active_slots || 0) >= Number(scheduler.target_active_slots || 0));
     const blockers = [
         ...(lifecycle.ok ? [] : ['agent_lifecycle_not_all_closed']),
         ...(lifecycle.ok ? [] : lifecycle.open_sessions.map((id) => 'session_open:' + id)),
@@ -144,7 +149,7 @@ export async function writeAgentProofEvidence(root, input) {
         ...(scheduler && scheduler.pending_count > 0 && scheduler.active_slot_count === 0 ? ['scheduler_pending_queue_without_active_sessions'] : []),
         ...(scheduler && scheduler.pending_queue_drained !== true ? ['scheduler_pending_queue_not_drained'] : []),
         ...(scheduler && Number(scheduler.active_slot_count || 0) !== 0 ? ['scheduler_active_slots_not_zero_at_finalization'] : []),
-        ...(scheduler && Number(scheduler.expected_backfill_count || 0) > Number(scheduler.backfill_count || 0) ? ['scheduler_backfill_count_below_expected'] : []),
+        ...(schedulerBackfillSatisfied ? [] : ['scheduler_backfill_count_below_expected']),
         ...(scheduler && Number(scheduler.total_work_items || 0) >= Number(scheduler.target_active_slots || 0) && Number(scheduler.max_observed_active_slots || 0) !== Number(scheduler.target_active_slots || 0) ? ['scheduler_max_observed_active_slots_mismatch'] : []),
         ...(taskGraph && !taskGraphMatchesCliOptions ? ['task_graph_cli_options_mismatch'] : []),
         ...(workQueue && taskGraph && !workQueueMatchesTaskGraph ? ['work_queue_task_graph_mismatch'] : []),

package/dist/core/agents/agent-runner-fake.js

@@ -23,6 +23,10 @@ export async function runFakeAgent(agent, slice, opts = {}) {
         unverified: ['fake backend does not prove real parallel execution'],
         writes: [],
         ...(patchEnvelopes.length ? { patch_envelopes: patchEnvelopes } : {}),
+        ...(isBugfixSlice(slice) && patchEnvelopes.length ? { regression_proof: fixtureRegressionProof(slice) } : {}),
+        ...(isRepairSlice(slice) && patchEnvelopes.length ? { repair_hypothesis: fixtureRepairHypothesis(slice) } : {}),
+        ...(slice?.work_item_kind ? { work_item_kind: String(slice.work_item_kind) } : {}),
+        ...(slice?.tournament_group_id ? { tournament: fixtureTournament(slice) } : {}),
         source_intelligence_refs: agent.source_intelligence_refs || null,
         goal_mode_ref: agent.goal_mode_ref || null,
         ...(opts.emitFollowUpWorkItems ? { follow_up_work_items: [buildFixtureFollowUp(agent, slice)] } : {}),
@@ -94,10 +98,46 @@ export function buildFixturePatchEnvelopes(agent, slice, opts = {}) {
                     path: file,
                     content: `patched by ${String(agent.id)} for ${String(slice?.id || 'fixture')}\n`
                 }],
+            ...(isBugfixSlice(slice) ? { regression_proof: fixtureRegressionProof(slice) } : {}),
+            ...(isRepairSlice(slice) ? { repair_hypothesis: fixtureRepairHypothesis(slice) } : {}),
+            ...(slice?.tournament_group_id ? { tournament: fixtureTournament(slice) } : {}),
             rationale: 'Fixture patch envelope emitted by fake backend for a leased write task.',
             verification_hint: { node_id: verificationNodeId, expected_status: 'applied_hashes_recorded' },
             rollback_hint: { node_id: rollbackNodeId, strategy: 'restore content_before or delete newly created file' }
         };
     });
 }
+function isBugfixSlice(slice) {
+    const text = `${String(slice?.work_item_kind || '')} ${String(slice?.title || '')}`.toLowerCase();
+    return /\b(bugfix|fix|bug|regression|broken|failure|crash|error)\b|버그|회귀/.test(text);
+}
+function isRepairSlice(slice) {
+    const text = `${String(slice?.work_item_kind || '')} ${String(slice?.title || '')}`.toLowerCase();
+    return /\b(conflict_resolution|repair|conflict|rebase|rollback)\b|수리|충돌/.test(text);
+}
+function fixtureRegressionProof(slice) {
+    return {
+        test_file: String(slice?.target_paths?.[0] || slice?.write_paths?.[0] || 'fixture.test.js'),
+        failed_before: true,
+        passed_after: true,
+        output_digest: 'fixture-regression-proof'
+    };
+}
+function fixtureRepairHypothesis(slice) {
+    return {
+        failure: 'fixture repair target',
+        hypotheses: [{ cause: 'fixture conflict', evidence_for: 'simulated failed worker', evidence_against: 'none' }],
+        chosen: 'fixture conflict',
+        minimal_probe: String(slice?.id || 'fixture')
+    };
+}
+function fixtureTournament(slice) {
+    return {
+        schema: 'sks.solution-tournament-candidate.v1',
+        group_id: String(slice.tournament_group_id),
+        candidate_index: Number(slice.tournament_candidate_index || 1),
+        candidate_count: Number(slice.tournament_candidate_count || 1),
+        approach: String(slice.approach_directive || '')
+    };
+}
 //# sourceMappingURL=agent-runner-fake.js.map

package/dist/core/agents/agent-scheduler.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { appendJsonl, nowIso, writeJsonAtomic } from '../fsx.js';
+import { appendJsonl, appendJsonlMany, nowIso, writeJsonAtomic } from '../fsx.js';
 import { MAX_AGENT_COUNT } from './agent-schema.js';
 import { appendAgentWorkQueueEvent, completeWorkItem, createAgentWorkQueue, enqueueFollowUpWorkItems, leaseNextWorkItem, pendingWorkItems, writeAgentWorkQueue } from './agent-work-queue.js';
 import { closeWorkerSlotsAfterDrain, createAgentWorkerSlots, markWorkerSlotGenerationClosed, openWorkerSlotGeneration, writeAgentWorkerSlots } from './agent-worker-slot.js';
@@ -290,8 +290,7 @@ export async function runAgentScheduler(input) {
         finally {
             batchDispatchInProgress = false;
         }
-        for (const event of launchEvents)
-            await appendJsonl(path.join(input.root, 'agent-scheduler-events.jsonl'), { schema: AGENT_SCHEDULER_EVENT_SCHEMA, ts: nowIso(), ...event });
+        await appendJsonlMany(path.join(input.root, 'agent-scheduler-events.jsonl'), launchEvents.map((event) => ({ schema: AGENT_SCHEDULER_EVENT_SCHEMA, ts: nowIso(), ...event })));
     }
     function collectLaunchBatch() {
         const launches = [];

package/dist/core/agents/agent-worker-pipeline.js

@@ -27,6 +27,7 @@ export function validateAgentWorkerResult(result) {
         session_id: String(result?.session_id || 'unknown'),
         persona_id: String(result?.persona_id || result?.agent_id || 'unknown'),
         task_slice_id: String(result?.task_slice_id || 'unknown'),
+        ...(result?.work_item_kind === undefined ? {} : { work_item_kind: String(result.work_item_kind) }),
         status: guard.ok ? (result?.status === undefined ? 'done' : String(result.status)) : 'blocked',
         backend: result?.backend || 'fake',
         summary: String(result?.summary || ''),
@@ -52,6 +53,10 @@ export function validateAgentWorkerResult(result) {
         ...(result?.model_authored_patch_envelopes === undefined ? {} : { model_authored_patch_envelopes: Boolean(result.model_authored_patch_envelopes) }),
         ...(result?.fixture_patch_envelopes === undefined ? {} : { fixture_patch_envelopes: Boolean(result.fixture_patch_envelopes) }),
         ...(result?.no_patch_reason === undefined ? {} : { no_patch_reason: result.no_patch_reason }),
+        ...(result?.machine_feedback === undefined ? {} : { machine_feedback: result.machine_feedback }),
+        ...(result?.regression_proof === undefined ? {} : { regression_proof: result.regression_proof }),
+        ...(result?.repair_hypothesis === undefined ? {} : { repair_hypothesis: result.repair_hypothesis }),
+        ...(result?.tournament === undefined ? {} : { tournament: result.tournament }),
         ...(result?.source_intelligence_refs === undefined ? {} : { source_intelligence_refs: result.source_intelligence_refs }),
         ...(result?.goal_mode_ref === undefined ? {} : { goal_mode_ref: result.goal_mode_ref }),
         ...(result?.follow_up_work_items === undefined ? {} : { follow_up_work_items: followUps.accepted }),
@@ -69,6 +74,12 @@ export function validateAgentWorkerResult(result) {
         normalized.blockers.push(...patchEnvelopeValidation.blockers.map((issue) => 'patch_envelope_invalid:' + issue));
         normalized.verification = { status: 'failed', checks: [...normalized.verification.checks, 'agent-patch-envelope-schema'] };
     }
+    const protocolBlockers = qualityProtocolBlockers(normalized);
+    if (protocolBlockers.length) {
+        normalized.status = 'blocked';
+        normalized.blockers.push(...protocolBlockers);
+        normalized.verification = { status: 'failed', checks: [...normalized.verification.checks, 'agent-worker-quality-protocol'] };
+    }
     const readOnlyOrNoopWithoutPatch = acceptsNoPatchReadOnlyOrNoop(result?.no_patch_reason);
     if (patchEnvelopeValidation.envelopes.length === 0 && (normalized.writes.length > 0 || (!readOnlyOrNoopWithoutPatch && normalized.changed_files.length > 0))) {
         normalized.status = 'blocked';
@@ -83,6 +94,24 @@ export function validateAgentWorkerResult(result) {
     }
     return normalized;
 }
+function qualityProtocolBlockers(result) {
+    const writesPatch = result.writes.length > 0 || result.changed_files.length > 0 || Boolean(result.patch_envelopes?.length);
+    if (!writesPatch)
+        return [];
+    const kind = String(result.work_item_kind || result.naruto_runtime?.work_item_kind || '').toLowerCase();
+    const text = [kind, result.task_slice_id].join(' ').toLowerCase();
+    const proof = result.regression_proof || result.patch_envelopes?.find((envelope) => envelope.regression_proof)?.regression_proof || null;
+    const repair = result.repair_hypothesis || result.patch_envelopes?.find((envelope) => envelope.repair_hypothesis)?.repair_hypothesis || null;
+    const blockers = [];
+    if ((kind === 'bugfix' || /\b(fix|bug|regression|broken|failure|crash|error)\b|버그|회귀/.test(text)) && !validRegressionProof(proof))
+        blockers.push('tdd_evidence_missing');
+    if ((kind === 'conflict_resolution' || /\b(repair|conflict|rebase|rollback)\b|수리|충돌/.test(text)) && !repair)
+        blockers.push('repair_without_hypothesis');
+    return blockers;
+}
+function validRegressionProof(proof) {
+    return Boolean(proof && proof.failed_before === true && proof.passed_after === true && String(proof.test_file || '').trim());
+}
 export function agentWorkerPipelineContract() {
     return {
         schema: 'sks.agent-worker-pipeline.v1',
@@ -97,7 +126,7 @@ export function agentWorkerPipelineContract() {
             required_for_write_tasks: true,
             envelope_schema: 'sks.agent-patch-envelope.v1',
             metadata: ['agent_id', 'session_id', 'slot_id', 'generation_index', 'lease_id_or_lease_proof'],
-            optional_hints: ['rationale', 'verification_hint', 'rollback_hint']
+            optional_hints: ['rationale', 'verification_hint', 'rollback_hint', 'cochange_acknowledged_reason', 'regression_proof', 'repair_hypothesis']
         }
     };
 }
@@ -111,7 +140,12 @@ function normalizePatchEnvelopes(value) {
         ...(raw?.generation_index === undefined ? {} : { generation_index: Number(raw.generation_index) }),
         ...(raw?.task_slice_id === undefined ? {} : { task_slice_id: String(raw.task_slice_id) }),
         ...(raw?.verification_hint === undefined ? {} : { verification_hint: raw.verification_hint }),
-        ...(raw?.rollback_hint === undefined ? {} : { rollback_hint: raw.rollback_hint })
+        ...(raw?.rollback_hint === undefined ? {} : { rollback_hint: raw.rollback_hint }),
+        ...(raw?.cochange_acknowledged === undefined ? {} : { cochange_acknowledged: Boolean(raw.cochange_acknowledged) }),
+        ...(raw?.cochange_acknowledged_reason === undefined ? {} : { cochange_acknowledged_reason: String(raw.cochange_acknowledged_reason) }),
+        ...(raw?.regression_proof === undefined ? {} : { regression_proof: raw.regression_proof }),
+        ...(raw?.repair_hypothesis === undefined ? {} : { repair_hypothesis: raw.repair_hypothesis }),
+        ...(raw?.tournament === undefined ? {} : { tournament: raw.tournament })
     })) : [];
     const blockers = envelopes.flatMap((envelope, index) => {
         const validation = validateAgentPatchEnvelope(envelope);

package/dist/core/agents/codex-exec-worker-adapter.js

@@ -112,6 +112,8 @@ function buildWorkerPrompt(slice) {
             `Write-capable slice. write_paths=${JSON.stringify(writePaths)}.`,
             'Return at least one patch_envelopes item with source "model_authored".',
             `Use a write operation for ${JSON.stringify(writePaths[0])}, allowed_paths equal to write_paths, lease_proof.protected_path_check "passed", and non-empty verification_hint and rollback_hint.`,
+            'Impact-scan, machine-feedback, diff-quality, and compiled mistake rules run before queue acceptance; exported signature changes must include cochanged callers or a concrete cochange_acknowledged_reason.',
+            'For bugfix work, add a regression test first and include regression_proof with failed_before true and passed_after true. For repair work, include repair_hypothesis before patching.',
             'For patch envelope runtime ids you cannot know yet, use numeric 0 or empty strings; SKS will bind actual worker and Codex child process ids from the process report.',
             'Set changed_files and writes consistently with the patch envelope operation.'
         ].join('\n')

package/dist/core/agents/native-cli-session-swarm.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { appendJsonl, ensureDir, exists, nowIso, packageRoot, readJson, writeJsonAtomic } from '../fsx.js';
 import { fastModeEnv } from './fast-mode-policy.js';
 import { validateAgentWorkerResult } from './agent-worker-pipeline.js';
-import { closeWorkerPane, openWorkerPane } from '../zellij/zellij-worker-pane-manager.js';
+import { closeWorkerPane, openHeadlessByDesignViewportWorker, openWorkerPane } from '../zellij/zellij-worker-pane-manager.js';
 import { closeWorkerInRightColumn, recordHeadlessWorkerInRightColumn } from '../zellij/zellij-right-column-manager.js';
 import { resolveProviderContext } from '../provider/provider-context.js';
 import { buildZellijSlotPaneCommand } from '../zellij/zellij-slot-pane-renderer.js';
@@ -110,17 +110,19 @@ class NativeCliSessionSwarmRecorder {
         const stdout = fs.createWriteStream(path.join(this.root, stdoutRel), { flags: 'a' });
         const stderr = fs.createWriteStream(path.join(this.root, stderrRel), { flags: 'a' });
         const placement = String(ctx.opts.workerPlacement || this.input.workerPlacement || (this.input.backend === 'zellij' ? 'zellij-pane' : 'process'));
-        const zellijReservation = placement === 'zellij-pane'
+        const legacyWorkerPanes = process.env.SKS_ZELLIJ_LEGACY_WORKER_PANES === '1';
+        const wantsZellijUi = placement === 'zellij-pane'
             && ctx.opts.zellijPaneWorker !== false
-            && (ctx.opts.zellijSessionName || this.input.missionId)
+            && (ctx.opts.zellijSessionName || this.input.missionId);
+        const zellijReservation = wantsZellijUi && legacyWorkerPanes
             ? this.reserveVisibleZellijPane(ctx.opts, String(ctx.agent.session_id || ctx.agent.id || `${Date.now()}:${Math.random()}`))
             : null;
-        const useZellijPane = Boolean(zellijReservation);
+        const useZellijPane = Boolean(zellijReservation) || (wantsZellijUi && !legacyWorkerPanes);
         await this.telemetry(ctx, {
             eventType: 'slot_reserved',
             status: placement === 'zellij-pane' && !useZellijPane ? 'headless' : 'queued',
             artifacts: [intakeRel, heartbeatRel, resultRel],
-            logTail: `placement=${placement}`
+            logTail: `placement=${placement}${wantsZellijUi && !legacyWorkerPanes ? ';viewport-ui=headless-by-design' : ''}`
         });
         if (useZellijPane) {
             stdout.end();
@@ -342,6 +344,11 @@ class NativeCliSessionSwarmRecorder {
                 artifactDir: path.join(this.root, input.workerDirRel),
                 backend: this.input.backend,
                 role,
+                provider: providerContext.provider,
+                model: String(process.env.SKS_MODEL || process.env.OPENAI_MODEL || process.env.CODEX_MODEL || ''),
+                serviceTier: this.input.fastModePolicy.service_tier,
+                reasoningEffort: String(input.ctx.agent.model_reasoning_effort || input.ctx.agent.reasoning_effort || process.env.SKS_REASONING_EFFORT || ''),
+                currentTask: String(input.ctx.slice?.title || input.ctx.slice?.description || input.ctx.slice?.id || ''),
                 mode: uiMode,
                 watch: true
             });
@@ -371,14 +378,14 @@ class NativeCliSessionSwarmRecorder {
                 session_id: input.ctx.agent.session_id || null,
                 pid: processRun.pid,
                 backend: this.input.backend,
-                placement: 'zellij-pane',
+                placement: process.env.SKS_ZELLIJ_LEGACY_WORKER_PANES === '1' ? 'zellij-pane' : 'headless_by_design_viewport_ui',
                 worktree_id: worktree?.id || null
             }).catch(() => undefined);
             await this.record(input.record);
         }
         let paneRecord;
         try {
-            paneRecord = await openWorkerPane({
+            const paneInput = {
                 root: this.root,
                 missionId: this.input.missionId,
                 sessionName,
@@ -402,22 +409,26 @@ class NativeCliSessionSwarmRecorder {
                 projectRoot: input.ctx.opts.projectRoot || this.input.projectRoot || input.ctx.opts.cwd,
                 rightColumnMode: 'spawn-on-first-worker',
                 visiblePaneCap: this.zellijVisiblePaneCap(input.ctx.opts),
+                plannedAgentCount: this.input.targetActiveSlots,
                 dashboardSnapshot: {
                     mode: this.input.route || '$Agent',
                     backend_counts: { [this.input.backend]: this.input.targetActiveSlots },
                     placement_counts: {
-                        'zellij-pane': this.zellijVisiblePaneCap(input.ctx.opts),
-                        headless: Math.max(0, this.input.targetActiveSlots - this.zellijVisiblePaneCap(input.ctx.opts))
+                        'zellij-pane': process.env.SKS_ZELLIJ_LEGACY_WORKER_PANES === '1' ? this.zellijVisiblePaneCap(input.ctx.opts) : 0,
+                        headless_by_design_viewport_ui: process.env.SKS_ZELLIJ_LEGACY_WORKER_PANES === '1' ? 0 : this.input.targetActiveSlots
                     },
                     active_workers: this.input.targetActiveSlots,
-                    visible_panes: this.zellijVisiblePaneCap(input.ctx.opts),
-                    headless_workers: Math.max(0, this.input.targetActiveSlots - this.zellijVisiblePaneCap(input.ctx.opts)),
+                    visible_panes: Number(process.env.SKS_ZELLIJ_VIEWPORTS || 4),
+                    headless_workers: process.env.SKS_ZELLIJ_LEGACY_WORKER_PANES === '1' ? Math.max(0, this.input.targetActiveSlots - this.zellijVisiblePaneCap(input.ctx.opts)) : this.input.targetActiveSlots,
                     queue_depth: Math.max(0, this.input.requestedAgents - this.input.targetActiveSlots),
                     local_llm: { tps: 0, queue: 0 },
                     gpt_final_status: 'pending',
                     gate_progress: 'worker-spawn'
                 }
-            });
+            };
+            paneRecord = process.env.SKS_ZELLIJ_LEGACY_WORKER_PANES === '1'
+                ? await openWorkerPane(paneInput)
+                : await openHeadlessByDesignViewportWorker(paneInput);
         }
         finally {
             if (input.zellijReservation)
@@ -426,7 +437,9 @@ class NativeCliSessionSwarmRecorder {
         const zellijRequired = process.env.SKS_REQUIRE_ZELLIJ === '1';
         const launchBlockers = zellijRequired ? paneRecord.blockers || [] : [];
         const launchWarnings = zellijRequired ? [] : paneRecord.blockers || [];
-        input.record.command_line = ['zellij', '--session', sessionName, 'action', 'new-pane', '--direction', paneRecord.direction_applied, '--name', paneRecord.pane_name, '--', 'sh', '-lc', liveWorkerPane ? '<native-cli-worker-command>' : '<zellij-slot-pane-renderer-command>'];
+        input.record.command_line = paneRecord.pane_id_source === 'headless_by_design_viewport_ui'
+            ? ['node', '<native-cli-worker-command>', '# headless-by-design viewport UI']
+            : ['zellij', '--session', sessionName, 'action', 'new-pane', '--direction', paneRecord.direction_applied, '--name', paneRecord.pane_name, '--', 'sh', '-lc', liveWorkerPane ? '<native-cli-worker-command>' : '<zellij-slot-pane-renderer-command>'];
         input.record.zellij_session_name = sessionName;
         input.record.zellij_pane_id = paneRecord.pane_id || null;
         input.record.zellij_pane_id_source = paneRecord.pane_id_source;
@@ -441,6 +454,10 @@ class NativeCliSessionSwarmRecorder {
         input.record.worktree = worktree;
         input.record.zellij_ui_mode = uiMode;
         input.record.slot_visualization = liveWorkerPane ? 'worker-command-pane' : 'zellij-slot-pane-renderer';
+        if (paneRecord.pane_id_source === 'headless_by_design_viewport_ui') {
+            input.record.worker_placement = 'headless_by_design_viewport_ui';
+            input.record.slot_visualization = 'monitor-plus-viewport';
+        }
         input.record.status = launchBlockers.length ? 'failed' : 'running';
         input.record.blockers = launchBlockers;
         input.record.warnings = [...(input.record.warnings || []), ...launchWarnings];

package/dist/core/agents/native-cli-worker.js

@@ -323,10 +323,11 @@ function startWorkerProgressTelemetry(input) {
             progress: null
         }, 2 * 1024 * 1024).catch(() => undefined);
         workerTelemetry(input.agentRoot, input.intake, input.agent, input.slice, {
-            eventType: 'heartbeat',
+            eventType: 'task_progress',
             status: 'running',
             backend: input.backend,
             serviceTier: input.serviceTier,
+            progress: { done: tick, total: 0, label: 'heartbeat' },
             artifacts: [input.heartbeatRel],
             logTail: `backend running ${tick}`
         }).catch(() => undefined);